]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
mm: Remove slab destructors from kmem_cache_create().
authorPaul Mundt <lethal@linux-sh.org>
Fri, 20 Jul 2007 01:11:58 +0000 (10:11 +0900)
committerPaul Mundt <lethal@linux-sh.org>
Fri, 20 Jul 2007 01:11:58 +0000 (10:11 +0900)
Slab destructors were no longer supported after Christoph's
c59def9f222d44bb7e2f0a559f2906191a0862d7 change. They've been
BUGs for both slab and slub, and slob never supported them
either.

This rips out support for the dtor pointer from kmem_cache_create()
completely and fixes up every single callsite in the kernel (there were
about 224, not including the slab allocator definitions themselves,
or the documentation references).

Signed-off-by: Paul Mundt <lethal@linux-sh.org>
165 files changed:
arch/arm/plat-s3c24xx/dma.c
arch/arm26/mm/memc.c
arch/i386/mm/init.c
arch/ia64/ia32/ia32_support.c
arch/powerpc/kernel/rtas_flash.c
arch/powerpc/mm/hugetlbpage.c
arch/powerpc/mm/init_64.c
arch/powerpc/platforms/cell/spufs/inode.c
arch/sh/kernel/cpu/sh4/sq.c
arch/sh/mm/pmb.c
arch/sparc64/mm/tsb.c
block/bsg.c
block/ll_rw_blk.c
drivers/acpi/osl.c
drivers/block/aoe/aoeblk.c
drivers/ieee1394/eth1394.c
drivers/infiniband/core/mad.c
drivers/infiniband/hw/amso1100/c2_vq.c
drivers/infiniband/hw/ehca/ehca_av.c
drivers/infiniband/hw/ehca/ehca_cq.c
drivers/infiniband/hw/ehca/ehca_main.c
drivers/infiniband/hw/ehca/ehca_mrmw.c
drivers/infiniband/hw/ehca/ehca_pd.c
drivers/infiniband/hw/ehca/ehca_qp.c
drivers/infiniband/ulp/iser/iscsi_iser.c
drivers/kvm/mmu.c
drivers/md/raid5.c
drivers/message/i2o/i2o_block.c
drivers/mtd/ubi/eba.c
drivers/mtd/ubi/wl.c
drivers/s390/block/dasd_devmap.c
drivers/s390/scsi/zfcp_aux.c
drivers/scsi/aic94xx/aic94xx_init.c
drivers/scsi/libsas/sas_init.c
drivers/scsi/qla2xxx/qla_os.c
drivers/scsi/qla4xxx/ql4_os.c
drivers/scsi/scsi.c
drivers/scsi/scsi_lib.c
drivers/scsi/scsi_tgt_lib.c
drivers/usb/host/uhci-hcd.c
drivers/usb/mon/mon_text.c
fs/adfs/super.c
fs/affs/super.c
fs/afs/super.c
fs/befs/linuxvfs.c
fs/bfs/inode.c
fs/bio.c
fs/block_dev.c
fs/cifs/cifsfs.c
fs/coda/inode.c
fs/configfs/mount.c
fs/dcache.c
fs/dcookies.c
fs/dlm/lowcomms.c
fs/dlm/memory.c
fs/dnotify.c
fs/dquot.c
fs/ecryptfs/main.c
fs/efs/super.c
fs/eventpoll.c
fs/ext2/super.c
fs/ext3/super.c
fs/ext4/super.c
fs/fat/cache.c
fs/fat/inode.c
fs/fcntl.c
fs/freevxfs/vxfs_super.c
fs/fuse/dev.c
fs/fuse/inode.c
fs/gfs2/main.c
fs/hfs/super.c
fs/hfsplus/super.c
fs/hpfs/super.c
fs/hugetlbfs/inode.c
fs/inode.c
fs/inotify_user.c
fs/isofs/inode.c
fs/jbd/journal.c
fs/jbd/revoke.c
fs/jbd2/journal.c
fs/jbd2/revoke.c
fs/jffs2/malloc.c
fs/jffs2/super.c
fs/jfs/jfs_metapage.c
fs/jfs/super.c
fs/locks.c
fs/mbcache.c
fs/minix/inode.c
fs/namespace.c
fs/ncpfs/inode.c
fs/nfs/direct.c
fs/nfs/inode.c
fs/nfs/pagelist.c
fs/nfs/read.c
fs/nfs/write.c
fs/nfsd/nfs4state.c
fs/ntfs/super.c
fs/ocfs2/dlm/dlmfs.c
fs/ocfs2/dlm/dlmmaster.c
fs/ocfs2/super.c
fs/ocfs2/uptodate.c
fs/openpromfs/inode.c
fs/proc/inode.c
fs/qnx4/inode.c
fs/reiserfs/super.c
fs/romfs/inode.c
fs/smbfs/inode.c
fs/smbfs/request.c
fs/sysfs/mount.c
fs/sysv/inode.c
fs/udf/super.c
fs/ufs/super.c
fs/xfs/linux-2.6/kmem.h
include/linux/i2o.h
include/linux/slab.h
ipc/mqueue.c
kernel/fork.c
kernel/nsproxy.c
kernel/posix-timers.c
kernel/user.c
lib/idr.c
lib/radix-tree.c
mm/mempolicy.c
mm/rmap.c
mm/shmem.c
mm/slab.c
mm/slob.c
mm/slub.c
net/bridge/br_fdb.c
net/core/flow.c
net/core/neighbour.c
net/core/skbuff.c
net/core/sock.c
net/dccp/ackvec.c
net/dccp/ccid.c
net/dccp/ccids/lib/loss_interval.c
net/dccp/ccids/lib/packet_history.c
net/dccp/proto.c
net/decnet/dn_route.c
net/decnet/dn_table.c
net/ipv4/fib_hash.c
net/ipv4/fib_trie.c
net/ipv4/inetpeer.c
net/ipv4/ipmr.c
net/ipv4/ipvs/ip_vs_conn.c
net/ipv4/route.c
net/ipv4/tcp.c
net/ipv6/ip6_fib.c
net/ipv6/route.c
net/ipv6/xfrm6_tunnel.c
net/netfilter/nf_conntrack_core.c
net/netfilter/nf_conntrack_expect.c
net/netfilter/xt_hashlimit.c
net/rxrpc/af_rxrpc.c
net/sctp/protocol.c
net/socket.c
net/sunrpc/rpc_pipe.c
net/sunrpc/sched.c
net/tipc/handler.c
net/xfrm/xfrm_input.c
net/xfrm/xfrm_policy.c
security/keys/key.c
security/selinux/avc.c
security/selinux/hooks.c
security/selinux/ss/avtab.c

index 08d80f2f51f2e5e047482ea47135034215ee08f1..6d048490c559ddcda21b7451584ca00609b97725 100644 (file)
@@ -1333,7 +1333,7 @@ int __init s3c24xx_dma_init(unsigned int channels, unsigned int irq,
        dma_kmem = kmem_cache_create("dma_desc",
                                     sizeof(struct s3c2410_dma_buf), 0,
                                     SLAB_HWCACHE_ALIGN,
-                                    s3c2410_dma_cache_ctor, NULL);
+                                    s3c2410_dma_cache_ctor);
 
        if (dma_kmem == NULL) {
                printk(KERN_ERR "dma failed to make kmem cache\n");
index 42505541a9b17836f8c30fbad66a19026b072a52..ffecd85782479b986e6c2b3f9d951e3d57c12d3d 100644 (file)
@@ -176,9 +176,9 @@ void __init pgtable_cache_init(void)
 {
        pte_cache = kmem_cache_create("pte-cache",
                                sizeof(pte_t) * PTRS_PER_PTE,
-                               0, SLAB_PANIC, pte_cache_ctor, NULL);
+                               0, SLAB_PANIC, pte_cache_ctor);
 
        pgd_cache = kmem_cache_create("pgd-cache", MEMC_TABLE_SIZE +
                                sizeof(pgd_t) * PTRS_PER_PGD,
-                               0, SLAB_PANIC, pgd_cache_ctor, NULL);
+                               0, SLAB_PANIC, pgd_cache_ctor);
 }
index 6a68b1ae061cf3a8626d9a8da3a91a4a61157459..6e72f22e6bbd840adf0311d55d2551afca690f0f 100644 (file)
@@ -752,8 +752,7 @@ void __init pgtable_cache_init(void)
                                        PTRS_PER_PMD*sizeof(pmd_t),
                                        PTRS_PER_PMD*sizeof(pmd_t),
                                        SLAB_PANIC,
-                                       pmd_ctor,
-                                       NULL);
+                                       pmd_ctor);
                if (!SHARED_KERNEL_PMD) {
                        /* If we're in PAE mode and have a non-shared
                           kernel pmd, then the pgd size must be a
index beea7a0b9dc6a090047fb3d550bfe79e90ed5995..e13a1a1db4b5ea096b09ee18293d283f917f1d19 100644 (file)
@@ -253,7 +253,7 @@ ia32_init (void)
 
                partial_page_cachep = kmem_cache_create("partial_page_cache",
                                                sizeof(struct partial_page),
-                                               0, SLAB_PANIC, NULL, NULL);
+                                               0, SLAB_PANIC, NULL);
        }
 #endif
        return 0;
index f72118c0844fa9da217893869db5ec657cc5a200..62b7bf2f3eab5a9fd77738d3689e167298900fa1 100644 (file)
@@ -804,7 +804,7 @@ int __init rtas_flash_init(void)
 
        flash_block_cache = kmem_cache_create("rtas_flash_cache",
                                RTAS_BLK_SIZE, RTAS_BLK_SIZE, 0,
-                               rtas_block_ctor, NULL);
+                               rtas_block_ctor);
        if (!flash_block_cache) {
                printk(KERN_ERR "%s: failed to create block cache\n",
                                __FUNCTION__);
index 92a1b16fb7e3bab4fe1716d228d32961b77ee302..4835f73af3044b7b57d6451cfc7c777a3806f1eb 100644 (file)
@@ -542,7 +542,7 @@ static int __init hugetlbpage_init(void)
                                               HUGEPTE_TABLE_SIZE,
                                               HUGEPTE_TABLE_SIZE,
                                               0,
-                                              zero_ctor, NULL);
+                                              zero_ctor);
        if (! huge_pgtable_cache)
                panic("hugetlbpage_init(): could not create hugepte cache\n");
 
index 1d6edf724c85da497f56048e2a590b89ba6e85d1..9f27bb56a61dadfba5f0d644f6e4987dbb91b23b 100644 (file)
@@ -178,7 +178,6 @@ void pgtable_cache_init(void)
                pgtable_cache[i] = kmem_cache_create(name,
                                                     size, size,
                                                     SLAB_PANIC,
-                                                    zero_ctor,
-                                                    NULL);
+                                                    zero_ctor);
        }
 }
index f37460e5bfd29b218775e7a8e9f1eb8da7274749..7eb4d6cbcb743cf73abb0545e3912a759df94ce8 100644 (file)
@@ -654,7 +654,7 @@ static int __init spufs_init(void)
        ret = -ENOMEM;
        spufs_inode_cache = kmem_cache_create("spufs_inode_cache",
                        sizeof(struct spufs_inode_info), 0,
-                       SLAB_HWCACHE_ALIGN, spufs_init_once, NULL);
+                       SLAB_HWCACHE_ALIGN, spufs_init_once);
 
        if (!spufs_inode_cache)
                goto out;
index d7fff752e569964652915e44a2197abe7eb85b5d..b98d6c3e6f36c3edb9b70a2e3ae07a1ac802be0a 100644 (file)
@@ -371,8 +371,7 @@ static int __init sq_api_init(void)
        printk(KERN_NOTICE "sq: Registering store queue API.\n");
 
        sq_cache = kmem_cache_create("store_queue_cache",
-                               sizeof(struct sq_mapping), 0, 0,
-                               NULL, NULL);
+                               sizeof(struct sq_mapping), 0, 0, NULL);
        if (unlikely(!sq_cache))
                return ret;
 
index b6a5a338145bf438037f40adfb3142a876a00e1c..a08a4a958adda563d0472b1534011da088f0524a 100644 (file)
@@ -310,7 +310,7 @@ static int __init pmb_init(void)
        BUG_ON(unlikely(nr_entries >= NR_PMB_ENTRIES));
 
        pmb_cache = kmem_cache_create("pmb", sizeof(struct pmb_entry), 0,
-                                     SLAB_PANIC, pmb_cache_ctor, NULL);
+                                     SLAB_PANIC, pmb_cache_ctor);
 
        jump_to_P2();
 
index 8eb8a7c76ec92fc171208f7b1b4179afebd3f12d..7ff0a02f58132e524a092f50b164605554e725ce 100644 (file)
@@ -262,8 +262,7 @@ void __init pgtable_cache_init(void)
 
                tsb_caches[i] = kmem_cache_create(name,
                                                  size, size,
-                                                 0,
-                                                 NULL, NULL);
+                                                 0, NULL);
                if (!tsb_caches[i]) {
                        prom_printf("Could not create %s cache\n", name);
                        prom_halt();
index baa04e7adf197331c34d4b0b46f8956f92b7b4b9..f2992e72b841e232d5d8b0296b6af9ddb90ac31b 100644 (file)
@@ -1043,7 +1043,7 @@ static int __init bsg_init(void)
        dev_t devid;
 
        bsg_cmd_cachep = kmem_cache_create("bsg_cmd",
-                               sizeof(struct bsg_command), 0, 0, NULL, NULL);
+                               sizeof(struct bsg_command), 0, 0, NULL);
        if (!bsg_cmd_cachep) {
                printk(KERN_ERR "bsg: failed creating slab cache\n");
                return -ENOMEM;
index d7cadf304168694d9ce542eea5f1c02930331a8a..66056ca5e6310256d1f1027da10a879fd15876bd 100644 (file)
@@ -3698,13 +3698,13 @@ int __init blk_dev_init(void)
                panic("Failed to create kblockd\n");
 
        request_cachep = kmem_cache_create("blkdev_requests",
-                       sizeof(struct request), 0, SLAB_PANIC, NULL, NULL);
+                       sizeof(struct request), 0, SLAB_PANIC, NULL);
 
        requestq_cachep = kmem_cache_create("blkdev_queue",
-                       sizeof(request_queue_t), 0, SLAB_PANIC, NULL, NULL);
+                       sizeof(request_queue_t), 0, SLAB_PANIC, NULL);
 
        iocontext_cachep = kmem_cache_create("blkdev_ioc",
-                       sizeof(struct io_context), 0, SLAB_PANIC, NULL, NULL);
+                       sizeof(struct io_context), 0, SLAB_PANIC, NULL);
 
        for_each_possible_cpu(i)
                INIT_LIST_HEAD(&per_cpu(blk_cpu_done, i));
index 2e7ba615d76043845f23c3dbd1f9192b5e4df072..00d53c2fd1e823bbf088863d3ae6577ef1da0606 100644 (file)
@@ -1098,7 +1098,7 @@ void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
 acpi_status
 acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
 {
-       *cache = kmem_cache_create(name, size, 0, 0, NULL, NULL);
+       *cache = kmem_cache_create(name, size, 0, 0, NULL);
        if (*cache == NULL)
                return AE_ERROR;
        else
index 478489c568a4c9f9de45cc05aba97f294d80bff8..4f598270fa31cd35f26d05c9ed11d3cb92915ffe 100644 (file)
@@ -257,9 +257,9 @@ aoeblk_exit(void)
 int __init
 aoeblk_init(void)
 {
-       buf_pool_cache = kmem_cache_create("aoe_bufs", 
+       buf_pool_cache = kmem_cache_create("aoe_bufs",
                                           sizeof(struct buf),
-                                          0, 0, NULL, NULL);
+                                          0, 0, NULL);
        if (buf_pool_cache == NULL)
                return -ENOMEM;
 
index 93362eed94eda0be345958ab069f0f78935c6443..3a9d7e2d4de6f229aaad1a9e4b334c9a573f71c1 100644 (file)
@@ -1729,7 +1729,7 @@ static int __init ether1394_init_module(void)
 
        packet_task_cache = kmem_cache_create("packet_task",
                                              sizeof(struct packet_task),
-                                             0, 0, NULL, NULL);
+                                             0, 0, NULL);
        if (!packet_task_cache)
                return -ENOMEM;
 
index 6b8faca02f8a169c779d56f547e5308bb398930c..bc547f1d34ba98d0dc5c5663f2e50b75ff6fe098 100644 (file)
@@ -2998,7 +2998,6 @@ static int __init ib_mad_init_module(void)
                                         sizeof(struct ib_mad_private),
                                         0,
                                         SLAB_HWCACHE_ALIGN,
-                                        NULL,
                                         NULL);
        if (!ib_mad_cache) {
                printk(KERN_ERR PFX "Couldn't create ib_mad cache\n");
index 36620a22413cd1f5f40e99e9f5ee138ad4a0ad85..cfdacb1ec279b15fb2f0ef43eb4789e6bd3ab654 100644 (file)
@@ -85,7 +85,7 @@ int vq_init(struct c2_dev *c2dev)
                (char) ('0' + c2dev->devnum));
        c2dev->host_msg_cache =
            kmem_cache_create(c2dev->vq_cache_name, c2dev->rep_vq.msg_size, 0,
-                             SLAB_HWCACHE_ALIGN, NULL, NULL);
+                             SLAB_HWCACHE_ALIGN, NULL);
        if (c2dev->host_msg_cache == NULL) {
                return -ENOMEM;
        }
index e53a97af126034c95f386193b2ca5909f16257c5..97d108634c5830c27012869d494be6656f92c23d 100644 (file)
@@ -259,7 +259,7 @@ int ehca_init_av_cache(void)
        av_cache = kmem_cache_create("ehca_cache_av",
                                   sizeof(struct ehca_av), 0,
                                   SLAB_HWCACHE_ALIGN,
-                                  NULL, NULL);
+                                  NULL);
        if (!av_cache)
                return -ENOMEM;
        return 0;
index 9e87883b561a1f409e69f1d634d1424cf0137230..1e8ca3fca4aa8d09d0fbb83c95633cdd8205e1c2 100644 (file)
@@ -387,7 +387,7 @@ int ehca_init_cq_cache(void)
        cq_cache = kmem_cache_create("ehca_cache_cq",
                                     sizeof(struct ehca_cq), 0,
                                     SLAB_HWCACHE_ALIGN,
-                                    NULL, NULL);
+                                    NULL);
        if (!cq_cache)
                return -ENOMEM;
        return 0;
index 36377c6db3d4a22ab6794cb9e954950dfd4a4668..04c324330b7cca4519d6618951893630ace4a17e 100644 (file)
@@ -163,7 +163,7 @@ static int ehca_create_slab_caches(void)
        ctblk_cache = kmem_cache_create("ehca_cache_ctblk",
                                        EHCA_PAGESIZE, H_CB_ALIGNMENT,
                                        SLAB_HWCACHE_ALIGN,
-                                       NULL, NULL);
+                                       NULL);
        if (!ctblk_cache) {
                ehca_gen_err("Cannot create ctblk SLAB cache.");
                ehca_cleanup_mrmw_cache();
index 6262c5462d5054afa89d7497c4aea4159eed9f45..9f4c9d46e8ef89b1df9a6a405c3ba011125d1834 100644 (file)
@@ -1950,13 +1950,13 @@ int ehca_init_mrmw_cache(void)
        mr_cache = kmem_cache_create("ehca_cache_mr",
                                     sizeof(struct ehca_mr), 0,
                                     SLAB_HWCACHE_ALIGN,
-                                    NULL, NULL);
+                                    NULL);
        if (!mr_cache)
                return -ENOMEM;
        mw_cache = kmem_cache_create("ehca_cache_mw",
                                     sizeof(struct ehca_mw), 0,
                                     SLAB_HWCACHE_ALIGN,
-                                    NULL, NULL);
+                                    NULL);
        if (!mw_cache) {
                kmem_cache_destroy(mr_cache);
                mr_cache = NULL;
index 79d0591a80431eb487fad97590f1ecfa83f531b1..c85312ad292b3876a4231ee048699256b0bd40bd 100644 (file)
@@ -100,7 +100,7 @@ int ehca_init_pd_cache(void)
        pd_cache = kmem_cache_create("ehca_cache_pd",
                                     sizeof(struct ehca_pd), 0,
                                     SLAB_HWCACHE_ALIGN,
-                                    NULL, NULL);
+                                    NULL);
        if (!pd_cache)
                return -ENOMEM;
        return 0;
index 48e9ceacd6fac10edfbfd396e9d5b52b8d784c2c..a3146e696c5debceffa8d6ae553a0ede19d3d4e4 100644 (file)
@@ -1760,7 +1760,7 @@ int ehca_init_qp_cache(void)
        qp_cache = kmem_cache_create("ehca_cache_qp",
                                     sizeof(struct ehca_qp), 0,
                                     SLAB_HWCACHE_ALIGN,
-                                    NULL, NULL);
+                                    NULL);
        if (!qp_cache)
                return -ENOMEM;
        return 0;
index effdee299b0c4ff2ade61260d2fe1b7a22509294..5db31438027109588ea50018a4875bfd64ae9521 100644 (file)
@@ -637,7 +637,7 @@ static int __init iser_init(void)
        ig.desc_cache = kmem_cache_create("iser_descriptors",
                                          sizeof (struct iser_desc),
                                          0, SLAB_HWCACHE_ALIGN,
-                                         NULL, NULL);
+                                         NULL);
        if (ig.desc_cache == NULL)
                return -ENOMEM;
 
index b297a6b111ac077074f3519e4dcbb8e6332ed8f8..1199d3f32ac3c296ca4973b6a38a29e979fe8b24 100644 (file)
@@ -1332,24 +1332,24 @@ int kvm_mmu_module_init(void)
 {
        pte_chain_cache = kmem_cache_create("kvm_pte_chain",
                                            sizeof(struct kvm_pte_chain),
-                                           0, 0, NULL, NULL);
+                                           0, 0, NULL);
        if (!pte_chain_cache)
                goto nomem;
        rmap_desc_cache = kmem_cache_create("kvm_rmap_desc",
                                            sizeof(struct kvm_rmap_desc),
-                                           0, 0, NULL, NULL);
+                                           0, 0, NULL);
        if (!rmap_desc_cache)
                goto nomem;
 
        mmu_page_cache = kmem_cache_create("kvm_mmu_page",
                                           PAGE_SIZE,
-                                          PAGE_SIZE, 0, NULL, NULL);
+                                          PAGE_SIZE, 0, NULL);
        if (!mmu_page_cache)
                goto nomem;
 
        mmu_page_header_cache = kmem_cache_create("kvm_mmu_page_header",
                                                  sizeof(struct kvm_mmu_page),
-                                                 0, 0, NULL, NULL);
+                                                 0, 0, NULL);
        if (!mmu_page_header_cache)
                goto nomem;
 
index 0b66afef2d82009be4f54c34880df588a8a22b61..c8dfdb302916aa81e10f2c82e55198e8daaf4f01 100644 (file)
@@ -951,7 +951,7 @@ static int grow_stripes(raid5_conf_t *conf, int num)
        conf->active_name = 0;
        sc = kmem_cache_create(conf->cache_name[conf->active_name],
                               sizeof(struct stripe_head)+(devs-1)*sizeof(struct r5dev),
-                              0, 0, NULL, NULL);
+                              0, 0, NULL);
        if (!sc)
                return 1;
        conf->slab_cache = sc;
@@ -1003,7 +1003,7 @@ static int resize_stripes(raid5_conf_t *conf, int newsize)
        /* Step 1 */
        sc = kmem_cache_create(conf->cache_name[1-conf->active_name],
                               sizeof(struct stripe_head)+(newsize-1)*sizeof(struct r5dev),
-                              0, 0, NULL, NULL);
+                              0, 0, NULL);
        if (!sc)
                return -ENOMEM;
 
index 64a52bd7544a8a4cf3adbdfafc34b9039460404a..988c8ce47f5816f6d29e0713724eb1ddcadbce61 100644 (file)
@@ -1171,8 +1171,7 @@ static int __init i2o_block_init(void)
        /* Allocate request mempool and slab */
        size = sizeof(struct i2o_block_request);
        i2o_blk_req_pool.slab = kmem_cache_create("i2o_block_req", size, 0,
-                                                 SLAB_HWCACHE_ALIGN, NULL,
-                                                 NULL);
+                                                 SLAB_HWCACHE_ALIGN, NULL);
        if (!i2o_blk_req_pool.slab) {
                osm_err("can't init request slab\n");
                rc = -ENOMEM;
index 8aff9385613f36601316ce0b9df2a4b410a2358a..7c5e29eaf1180737341e49be803515a8f41c3c33 100644 (file)
@@ -1149,7 +1149,7 @@ int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
        if (ubi_devices_cnt == 0) {
                ltree_slab = kmem_cache_create("ubi_ltree_slab",
                                               sizeof(struct ltree_entry), 0,
-                                              0, &ltree_entry_ctor, NULL);
+                                              0, &ltree_entry_ctor);
                if (!ltree_slab)
                        return -ENOMEM;
        }
index 9de953762097c8d1746994246e8e00b91ec3d101..a5a9b8d873025ad5e1ac39fe8c38d377487e5619 100644 (file)
@@ -1452,7 +1452,7 @@ int ubi_wl_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si)
        if (ubi_devices_cnt == 0) {
                wl_entries_slab = kmem_cache_create("ubi_wl_entry_slab",
                                                    sizeof(struct ubi_wl_entry),
-                                                   0, 0, NULL, NULL);
+                                                   0, 0, NULL);
                if (!wl_entries_slab)
                        return -ENOMEM;
        }
index 6a89cefe99bbd10dadf8f8363a0ab8553d8f79b1..0c67258fb9ec07cb6351edb1a4ee307848f4db67 100644 (file)
@@ -291,7 +291,7 @@ dasd_parse_keyword( char *parsestring ) {
                dasd_page_cache =
                        kmem_cache_create("dasd_page_cache", PAGE_SIZE,
                                          PAGE_SIZE, SLAB_CACHE_DMA,
-                                         NULL, NULL );
+                                         NULL);
                if (!dasd_page_cache)
                        MESSAGE(KERN_WARNING, "%s", "Failed to create slab, "
                                "fixed buffer mode disabled.");
index a1db95925138c959cfe5894668289b281fee6a21..9726261c367df820fe78c044e21eda69e10559ca 100644 (file)
@@ -259,21 +259,21 @@ zfcp_module_init(void)
        size = sizeof(struct zfcp_fsf_req_qtcb);
        align = calc_alignment(size);
        zfcp_data.fsf_req_qtcb_cache =
-               kmem_cache_create("zfcp_fsf", size, align, 0, NULL, NULL);
+               kmem_cache_create("zfcp_fsf", size, align, 0, NULL);
        if (!zfcp_data.fsf_req_qtcb_cache)
                goto out;
 
        size = sizeof(struct fsf_status_read_buffer);
        align = calc_alignment(size);
        zfcp_data.sr_buffer_cache =
-               kmem_cache_create("zfcp_sr", size, align, 0, NULL, NULL);
+               kmem_cache_create("zfcp_sr", size, align, 0, NULL);
        if (!zfcp_data.sr_buffer_cache)
                goto out_sr_cache;
 
        size = sizeof(struct zfcp_gid_pn_data);
        align = calc_alignment(size);
        zfcp_data.gid_pn_cache =
-               kmem_cache_create("zfcp_gid", size, align, 0, NULL, NULL);
+               kmem_cache_create("zfcp_gid", size, align, 0, NULL);
        if (!zfcp_data.gid_pn_cache)
                goto out_gid_cache;
 
index 1c0d7578e791e8fbeaeaa147dc54360cc85e1c1a..b8c6810090d54a4981bc68db13b274090c79eacc 100644 (file)
@@ -462,7 +462,7 @@ static int asd_create_global_caches(void)
                                            sizeof(struct asd_dma_tok),
                                            0,
                                            SLAB_HWCACHE_ALIGN,
-                                           NULL, NULL);
+                                           NULL);
                if (!asd_dma_token_cache) {
                        asd_printk("couldn't create dma token cache\n");
                        return -ENOMEM;
@@ -474,7 +474,7 @@ static int asd_create_global_caches(void)
                                                   sizeof(struct asd_ascb),
                                                   0,
                                                   SLAB_HWCACHE_ALIGN,
-                                                  NULL, NULL);
+                                                  NULL);
                if (!asd_ascb_cache) {
                        asd_printk("couldn't create ascb cache\n");
                        goto Err;
index 965698c8b7bff407cf2157922b93e7895ede92e7..1396c83b0c9ccbfd1a15b2b198ee45a6ab55aee6 100644 (file)
@@ -292,7 +292,7 @@ EXPORT_SYMBOL_GPL(sas_domain_release_transport);
 static int __init sas_class_init(void)
 {
        sas_task_cache = kmem_cache_create("sas_task", sizeof(struct sas_task),
-                                          0, SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                          0, SLAB_HWCACHE_ALIGN, NULL);
        if (!sas_task_cache)
                return -ENOMEM;
 
index b5a77b0c0deb6d5f7d3b7e878b986bc76f4cb400..92376f9dfdd50b057f5a9e70c15be322fa015dfe 100644 (file)
@@ -2723,7 +2723,7 @@ qla2x00_module_init(void)
 
        /* Allocate cache for SRBs. */
        srb_cachep = kmem_cache_create("qla2xxx_srbs", sizeof(srb_t), 0,
-           SLAB_HWCACHE_ALIGN, NULL, NULL);
+           SLAB_HWCACHE_ALIGN, NULL);
        if (srb_cachep == NULL) {
                printk(KERN_ERR
                    "qla2xxx: Unable to allocate SRB cache...Failing load!\n");
index e69160a7bc600e6ce3ce4604225db09be90f1d16..b1d565c12c5b9af0da0350f909c11e95f9617b59 100644 (file)
@@ -1677,7 +1677,7 @@ static int __init qla4xxx_module_init(void)
 
        /* Allocate cache for SRBs. */
        srb_cachep = kmem_cache_create("qla4xxx_srbs", sizeof(struct srb), 0,
-                                      SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                      SLAB_HWCACHE_ALIGN, NULL);
        if (srb_cachep == NULL) {
                printk(KERN_ERR
                       "%s: Unable to allocate SRB cache..."
index a691dda40d2c47603f7a78f2ebe3b4ca2366335b..a5de1a829a76dbb2bba8d6baaa4cc8e7bd580805 100644 (file)
@@ -288,7 +288,7 @@ int scsi_setup_command_freelist(struct Scsi_Host *shost)
        if (!pool->users) {
                pool->slab = kmem_cache_create(pool->name,
                                sizeof(struct scsi_cmnd), 0,
-                               pool->slab_flags, NULL, NULL);
+                               pool->slab_flags, NULL);
                if (!pool->slab)
                        goto fail;
        }
index 1f5a07bf2a7535e439300b4daa51f898983973ef..da63c544919bd9f306df81dae5d8c7a7951fcb5b 100644 (file)
@@ -1661,7 +1661,7 @@ int __init scsi_init_queue(void)
 
        scsi_io_context_cache = kmem_cache_create("scsi_io_context",
                                        sizeof(struct scsi_io_context),
-                                       0, 0, NULL, NULL);
+                                       0, 0, NULL);
        if (!scsi_io_context_cache) {
                printk(KERN_ERR "SCSI: can't init scsi io context cache\n");
                return -ENOMEM;
@@ -1672,7 +1672,7 @@ int __init scsi_init_queue(void)
                int size = sgp->size * sizeof(struct scatterlist);
 
                sgp->slab = kmem_cache_create(sgp->name, size, 0,
-                               SLAB_HWCACHE_ALIGN, NULL, NULL);
+                               SLAB_HWCACHE_ALIGN, NULL);
                if (!sgp->slab) {
                        printk(KERN_ERR "SCSI: can't init sg slab %s\n",
                                        sgp->name);
index 2570f48a69c7a78c40ddd325fc9c0a305fcc19b9..371b69c110bcc5403b81d4b046ba31dc9888cc9e 100644 (file)
@@ -585,7 +585,7 @@ static int __init scsi_tgt_init(void)
 
        scsi_tgt_cmd_cache = kmem_cache_create("scsi_tgt_cmd",
                                               sizeof(struct scsi_tgt_cmd),
-                                              0, 0, NULL, NULL);
+                                              0, 0, NULL);
        if (!scsi_tgt_cmd_cache)
                return -ENOMEM;
 
index 76c555a67dacc3931649d40f706f94ad2405dc68..805e5fc5f5db48da68ef0eb609d63a057d39ca21 100644 (file)
@@ -933,7 +933,7 @@ static int __init uhci_hcd_init(void)
        }
 
        uhci_up_cachep = kmem_cache_create("uhci_urb_priv",
-               sizeof(struct urb_priv), 0, 0, NULL, NULL);
+               sizeof(struct urb_priv), 0, 0, NULL);
        if (!uhci_up_cachep)
                goto up_failed;
 
index 982b773d71e69f186210322e98c434ba78425d21..8f27a9e1c36ba7c0b38a5ca4b9acb5ced9ab7da3 100644 (file)
@@ -340,7 +340,7 @@ static int mon_text_open(struct inode *inode, struct file *file)
        snprintf(rp->slab_name, SLAB_NAME_SZ, "mon_text_%p", rp);
        rp->e_slab = kmem_cache_create(rp->slab_name,
            sizeof(struct mon_event_text), sizeof(long), 0,
-           mon_text_ctor, NULL);
+           mon_text_ctor);
        if (rp->e_slab == NULL) {
                rc = -ENOMEM;
                goto err_slab;
index de2ed5ca335192f44e813b52e2b840b0c94c2a1f..1c9fd3029496f577a69252b119adc817ff26fe85 100644 (file)
@@ -234,14 +234,14 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 
        inode_init_once(&ei->vfs_inode);
 }
+
 static int init_inodecache(void)
 {
        adfs_inode_cachep = kmem_cache_create("adfs_inode_cache",
                                             sizeof(struct adfs_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (adfs_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 6d0ebc3215301b3c66dfa54670c9a079674cec5c..c80191ae2059d751ee413a244892934ba39b9733 100644 (file)
@@ -99,7 +99,7 @@ static int init_inodecache(void)
                                             sizeof(struct affs_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (affs_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 993cdf1cce3a494b40a7df32166813a17756bd4d..b8808b40f82b3c01f35fb37e3c88a67a36775170 100644 (file)
@@ -89,8 +89,7 @@ int __init afs_fs_init(void)
                                             sizeof(struct afs_vnode),
                                             0,
                                             SLAB_HWCACHE_ALIGN,
-                                            afs_i_init_once,
-                                            NULL);
+                                            afs_i_init_once);
        if (!afs_inode_cachep) {
                printk(KERN_NOTICE "kAFS: Failed to allocate inode cache\n");
                return ret;
index a5c5171c2828997baa249bcad6d360c657969a79..a45141827681c9294518cbbb1185033dcdd2dcc4 100644 (file)
@@ -414,7 +414,7 @@ befs_read_inode(struct inode *inode)
 }
 
 /* Initialize the inode cache. Called at fs setup.
- * 
+ *
  * Taken from NFS implementation by Al Viro.
  */
 static int
@@ -424,7 +424,7 @@ befs_init_inodecache(void)
                                              sizeof (struct befs_inode_info),
                                              0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                             init_once, NULL);
+                                             init_once);
        if (befs_inode_cachep == NULL) {
                printk(KERN_ERR "befs_init_inodecache: "
                       "Couldn't initalize inode slabcache\n");
index 58c7bd9f5301539294531c6557a097dcd780422d..f346eb14e86f37b88a820a7231eb10dc19414fd6 100644 (file)
@@ -250,14 +250,14 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 
        inode_init_once(&bi->vfs_inode);
 }
+
 static int init_inodecache(void)
 {
        bfs_inode_cachep = kmem_cache_create("bfs_inode_cache",
                                             sizeof(struct bfs_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (bfs_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 33e46340a76666ebca0bc1b8aa3a40f44d6d1535..0d2c2d38b7ba8ae7599886dea168cb537c8f1806 100644 (file)
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -1187,7 +1187,7 @@ static void __init biovec_init_slabs(void)
 
                size = bvs->nr_vecs * sizeof(struct bio_vec);
                bvs->slab = kmem_cache_create(bvs->name, size, 0,
-                                SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                                SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
        }
 }
 
index 3635315e3b99837c4c324baddb033fc2b212a99c..2980eabe577981c0852a9286eea9be4474143687 100644 (file)
@@ -517,7 +517,7 @@ void __init bdev_cache_init(void)
        bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode),
                        0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
                                SLAB_MEM_SPREAD|SLAB_PANIC),
-                       init_once, NULL);
+                       init_once);
        err = register_filesystem(&bd_type);
        if (err)
                panic("Cannot register bdev pseudo-fs");
index 1fd0dc85f53c9a25a8f2cac7ab6c9a41e77b930e..cabb6a55d7ddaf2d3e19ce22ae1c20e38fd5ff0b 100644 (file)
@@ -719,7 +719,7 @@ cifs_init_inodecache(void)
                                              sizeof (struct cifsInodeInfo),
                                              0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                             cifs_init_once, NULL);
+                                             cifs_init_once);
        if (cifs_inode_cachep == NULL)
                return -ENOMEM;
 
@@ -748,7 +748,7 @@ cifs_init_request_bufs(void)
        cifs_req_cachep = kmem_cache_create("cifs_request",
                                            CIFSMaxBufSize +
                                            MAX_CIFS_HDR_SIZE, 0,
-                                           SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                           SLAB_HWCACHE_ALIGN, NULL);
        if (cifs_req_cachep == NULL)
                return -ENOMEM;
 
@@ -776,7 +776,7 @@ cifs_init_request_bufs(void)
        alloc of large cifs buffers even when page debugging is on */
        cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
                        MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
-                       NULL, NULL);
+                       NULL);
        if (cifs_sm_req_cachep == NULL) {
                mempool_destroy(cifs_req_poolp);
                kmem_cache_destroy(cifs_req_cachep);
@@ -817,7 +817,7 @@ cifs_init_mids(void)
 {
        cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
                                sizeof (struct mid_q_entry), 0,
-                               SLAB_HWCACHE_ALIGN, NULL, NULL);
+                               SLAB_HWCACHE_ALIGN, NULL);
        if (cifs_mid_cachep == NULL)
                return -ENOMEM;
 
@@ -830,7 +830,7 @@ cifs_init_mids(void)
 
        cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
                                sizeof (struct oplock_q_entry), 0,
-                               SLAB_HWCACHE_ALIGN, NULL, NULL);
+                               SLAB_HWCACHE_ALIGN, NULL);
        if (cifs_oplock_cachep == NULL) {
                mempool_destroy(cifs_mid_poolp);
                kmem_cache_destroy(cifs_mid_cachep);
index 6771a4271e33bbf5dd5e4f8b4730b64b98061891..342f4e0d582e6468ff41eaaab4eac3f2674b3552 100644 (file)
@@ -64,13 +64,13 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 
        inode_init_once(&ei->vfs_inode);
 }
+
 int coda_init_inodecache(void)
 {
        coda_inode_cachep = kmem_cache_create("coda_inode_cache",
                                sizeof(struct coda_inode_info),
                                0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
-                               init_once, NULL);
+                               init_once);
        if (coda_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index b00d962de833a9ad6eb845b67ed4f653cb9f8c9d..871b0cb618399223e3e500cae1a46b54c42475b9 100644 (file)
@@ -136,7 +136,7 @@ static int __init configfs_init(void)
 
        configfs_dir_cachep = kmem_cache_create("configfs_dir_cache",
                                                sizeof(struct configfs_dirent),
-                                               0, 0, NULL, NULL);
+                                               0, 0, NULL);
        if (!configfs_dir_cachep)
                goto out;
 
index cb9d05056b54368728d0d38c59ebda240f233476..678d39deb60770dffb5cbbbc0de1e84d6e139f36 100644 (file)
@@ -2165,10 +2165,10 @@ void __init vfs_caches_init(unsigned long mempages)
        mempages -= reserve;
 
        names_cachep = kmem_cache_create("names_cache", PATH_MAX, 0,
-                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 
        filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
-                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 
        dcache_init(mempages);
        inode_init(mempages);
index 21af1629f9bcc2ebd6eda9d701bb31b1e03feb49..c1208f53bd74596c74423f085886c859bf51cf3e 100644 (file)
@@ -205,7 +205,7 @@ static int dcookie_init(void)
 
        dcookie_cache = kmem_cache_create("dcookie_cache",
                sizeof(struct dcookie_struct),
-               0, 0, NULL, NULL);
+               0, 0, NULL);
 
        if (!dcookie_cache)
                goto out;
index 0553a6158dcbcf1bcc89d4e5d0733419ffc88214..dd362739d291e8a5d125ec2d2172e19d497bdecc 100644 (file)
@@ -1449,7 +1449,7 @@ int dlm_lowcomms_start(void)
        error = -ENOMEM;
        con_cache = kmem_cache_create("dlm_conn", sizeof(struct connection),
                                      __alignof__(struct connection), 0,
-                                     NULL, NULL);
+                                     NULL);
        if (!con_cache)
                goto out;
 
index fb9e2ee998ae1c9feccc509473f6aa56823759ec..ecf0e5cb2035e885e90bf8acbc992c3c9b0c397d 100644 (file)
@@ -23,7 +23,7 @@ int dlm_memory_init(void)
        int ret = 0;
 
        lkb_cache = kmem_cache_create("dlm_lkb", sizeof(struct dlm_lkb),
-                               __alignof__(struct dlm_lkb), 0, NULL, NULL);
+                               __alignof__(struct dlm_lkb), 0, NULL);
        if (!lkb_cache)
                ret = -ENOMEM;
        return ret;
index 936409fcd9397a9909e74fd7547d609ee1e57986..28d01ed66de0198130407a9d36411f77946cd1c7 100644 (file)
@@ -176,7 +176,7 @@ EXPORT_SYMBOL_GPL(dnotify_parent);
 static int __init dnotify_init(void)
 {
        dn_cache = kmem_cache_create("dnotify_cache",
-               sizeof(struct dnotify_struct), 0, SLAB_PANIC, NULL, NULL);
+               sizeof(struct dnotify_struct), 0, SLAB_PANIC, NULL);
        return 0;
 }
 
index 7e273151f58949a09a58ea6d89219b520d8fe72c..de9a29f64ff3bd65dd082b08fa74aa18f02b0ab5 100644 (file)
@@ -1848,11 +1848,11 @@ static int __init dquot_init(void)
 
        register_sysctl_table(sys_table);
 
-       dquot_cachep = kmem_cache_create("dquot", 
+       dquot_cachep = kmem_cache_create("dquot",
                        sizeof(struct dquot), sizeof(unsigned long) * 4,
                        (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
                                SLAB_MEM_SPREAD|SLAB_PANIC),
-                       NULL, NULL);
+                       NULL);
 
        order = 0;
        dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order);
index 02ca6f1e55d77d09ddd4d057c9e02bdc8c33ef5a..e557a676692734193b85d091aceb04694d274716 100644 (file)
@@ -677,7 +677,7 @@ static int ecryptfs_init_kmem_caches(void)
 
                info = &ecryptfs_cache_infos[i];
                *(info->cache) = kmem_cache_create(info->name, info->size,
-                               0, SLAB_HWCACHE_ALIGN, info->ctor, NULL);
+                               0, SLAB_HWCACHE_ALIGN, info->ctor);
                if (!*(info->cache)) {
                        ecryptfs_free_kmem_caches();
                        ecryptfs_printk(KERN_WARNING, "%s: "
index d360c81f3a729b7a282ef5da9a99fe65ffb43335..ce4acb8ff819a70b4f76733bd804c7d72e0beb2b 100644 (file)
@@ -75,13 +75,13 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 
        inode_init_once(&ei->vfs_inode);
 }
+
 static int init_inodecache(void)
 {
        efs_inode_cachep = kmem_cache_create("efs_inode_cache",
                                sizeof(struct efs_inode_info),
                                0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
-                               init_once, NULL);
+                               init_once);
        if (efs_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 0b73cd45a06d6a05a2b37231a39a51cf1b8a8e4e..77b9953624f480e37d80fb13010fb3e1bc8b3c51 100644 (file)
@@ -1324,12 +1324,12 @@ static int __init eventpoll_init(void)
        /* Allocates slab cache used to allocate "struct epitem" items */
        epi_cache = kmem_cache_create("eventpoll_epi", sizeof(struct epitem),
                        0, SLAB_HWCACHE_ALIGN|EPI_SLAB_DEBUG|SLAB_PANIC,
-                       NULL, NULL);
+                       NULL);
 
        /* Allocates slab cache used to allocate "struct eppoll_entry" */
        pwq_cache = kmem_cache_create("eventpoll_pwq",
                        sizeof(struct eppoll_entry), 0,
-                       EPI_SLAB_DEBUG|SLAB_PANIC, NULL, NULL);
+                       EPI_SLAB_DEBUG|SLAB_PANIC, NULL);
 
        return 0;
 }
index a6b1072daea7ee1e903f9f4aac32c1efcde7b85b..68579a0ed3f0a6617b8ecbe59e9ce826f5be2f2d 100644 (file)
@@ -167,14 +167,14 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 #endif
        inode_init_once(&ei->vfs_inode);
 }
+
 static int init_inodecache(void)
 {
        ext2_inode_cachep = kmem_cache_create("ext2_inode_cache",
                                             sizeof(struct ext2_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (ext2_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 4f84dc86628aeeb96706fc11c844442ff9b875f2..f0614e3f1fe82dc927fb604c1be4ce30b2be2df9 100644 (file)
@@ -490,7 +490,7 @@ static int init_inodecache(void)
                                             sizeof(struct ext3_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (ext3_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 6dcbb28dc06d73edd841d6ecb8a1e93570ef4c29..75adbb64e028e6c1e3d3acfb9baabdd2601ac9cd 100644 (file)
@@ -541,7 +541,7 @@ static int init_inodecache(void)
                                             sizeof(struct ext4_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (ext4_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 3c9c8a15ec73fec582d6959b3f1d41e1c4ab5edc..be6f89b152caf6e69d3afb160eb508c65e46bd26 100644 (file)
@@ -48,7 +48,7 @@ int __init fat_cache_init(void)
        fat_cache_cachep = kmem_cache_create("fat_cache",
                                sizeof(struct fat_cache),
                                0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
-                               init_once, NULL);
+                               init_once);
        if (fat_cache_cachep == NULL)
                return -ENOMEM;
        return 0;
index 0a7ddb39a593f295c6148a243d6109bb95ba3730..4baa5f2053680944dcc480a95da6bbea7f384c62 100644 (file)
@@ -514,7 +514,7 @@ static int __init fat_init_inodecache(void)
                                             sizeof(struct msdos_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (fat_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 3f22e9f4f691ae3cb44312921c0aaf3a6b382086..78b2ff04405400c724c9aff18a0f000be577c908 100644 (file)
@@ -638,7 +638,7 @@ EXPORT_SYMBOL(kill_fasync);
 static int __init fasync_init(void)
 {
        fasync_cache = kmem_cache_create("fasync_cache",
-               sizeof(struct fasync_struct), 0, SLAB_PANIC, NULL, NULL);
+               sizeof(struct fasync_struct), 0, SLAB_PANIC, NULL);
        return 0;
 }
 
index 647d600f0bc82d7399732e83f8c2f71d5ab625b3..4f95572d2722d047d0e7e1ac3307ca47bf6122e4 100644 (file)
@@ -263,8 +263,8 @@ vxfs_init(void)
        int rv;
 
        vxfs_inode_cachep = kmem_cache_create("vxfs_inode",
-                       sizeof(struct vxfs_inode_info), 0, 
-                       SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL, NULL);
+                       sizeof(struct vxfs_inode_info), 0,
+                       SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL);
        if (!vxfs_inode_cachep)
                return -ENOMEM;
        rv = register_filesystem(&vxfs_fs_type);
index 357764d85ff1e0cc81723f4006f78479e5164fc8..3ad22beb24c2ed3adf973099e4ed8dc87c9e48be 100644 (file)
@@ -1044,7 +1044,7 @@ int __init fuse_dev_init(void)
        int err = -ENOMEM;
        fuse_req_cachep = kmem_cache_create("fuse_request",
                                            sizeof(struct fuse_req),
-                                           0, 0, NULL, NULL);
+                                           0, 0, NULL);
        if (!fuse_req_cachep)
                goto out;
 
index cc5efc13496ab5eb431a3aafa4f91d7df5842eb2..5448f625ab567730b89cf5dd7ac58e1939185e82 100644 (file)
@@ -706,7 +706,7 @@ static int __init fuse_fs_init(void)
        fuse_inode_cachep = kmem_cache_create("fuse_inode",
                                              sizeof(struct fuse_inode),
                                              0, SLAB_HWCACHE_ALIGN,
-                                             fuse_inode_init_once, NULL);
+                                             fuse_inode_init_once);
        err = -ENOMEM;
        if (!fuse_inode_cachep)
                goto out_unreg2;
index 787a0edef100504727184274622d21c48385af93..d5d4e68b88070430e667aec80d1bb91b6e571c28 100644 (file)
@@ -72,7 +72,7 @@ static int __init init_gfs2_fs(void)
        gfs2_glock_cachep = kmem_cache_create("gfs2_glock",
                                              sizeof(struct gfs2_glock),
                                              0, 0,
-                                             gfs2_init_glock_once, NULL);
+                                             gfs2_init_glock_once);
        if (!gfs2_glock_cachep)
                goto fail;
 
@@ -80,13 +80,13 @@ static int __init init_gfs2_fs(void)
                                              sizeof(struct gfs2_inode),
                                              0,  SLAB_RECLAIM_ACCOUNT|
                                                  SLAB_MEM_SPREAD,
-                                             gfs2_init_inode_once, NULL);
+                                             gfs2_init_inode_once);
        if (!gfs2_inode_cachep)
                goto fail;
 
        gfs2_bufdata_cachep = kmem_cache_create("gfs2_bufdata",
                                                sizeof(struct gfs2_bufdata),
-                                               0, 0, NULL, NULL);
+                                               0, 0, NULL);
        if (!gfs2_bufdata_cachep)
                goto fail;
 
index 92cf8751e428728cfb9902580be7ce2a6357c54d..6c5f92dfb50036105ba5de2739572a5036cf23b0 100644 (file)
@@ -443,7 +443,7 @@ static int __init init_hfs_fs(void)
 
        hfs_inode_cachep = kmem_cache_create("hfs_inode_cache",
                sizeof(struct hfs_inode_info), 0, SLAB_HWCACHE_ALIGN,
-               hfs_init_once, NULL);
+               hfs_init_once);
        if (!hfs_inode_cachep)
                return -ENOMEM;
        err = register_filesystem(&hfs_fs_type);
index 6d87a2a9534d4baa56dbd466016106b78d87daa9..7b0f2e5a44e2bce847c9c3e59c141c4a4821639f 100644 (file)
@@ -479,7 +479,7 @@ static int __init init_hfsplus_fs(void)
 
        hfsplus_inode_cachep = kmem_cache_create("hfsplus_icache",
                HFSPLUS_INODE_SIZE, 0, SLAB_HWCACHE_ALIGN,
-               hfsplus_init_once, NULL);
+               hfsplus_init_once);
        if (!hfsplus_inode_cachep)
                return -ENOMEM;
        err = register_filesystem(&hfsplus_fs_type);
index 29cc34abb2ea960c37f05111e09b683690493afb..89612ee7c80d6d9ffb5370ecb83f7716e1427f05 100644 (file)
@@ -181,14 +181,14 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
        mutex_init(&ei->i_parent_mutex);
        inode_init_once(&ei->vfs_inode);
 }
+
 static int init_inodecache(void)
 {
        hpfs_inode_cachep = kmem_cache_create("hpfs_inode_cache",
                                             sizeof(struct hpfs_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (hpfs_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index d145cb79c30a4dd3caea5f328737e3418e96548f..c848a191525db4776bec08970538449c442ffb81 100644 (file)
@@ -848,7 +848,7 @@ static int __init init_hugetlbfs_fs(void)
 
        hugetlbfs_inode_cachep = kmem_cache_create("hugetlbfs_inode_cache",
                                        sizeof(struct hugetlbfs_inode_info),
-                                       0, 0, init_once, NULL);
+                                       0, 0, init_once);
        if (hugetlbfs_inode_cachep == NULL)
                return -ENOMEM;
 
index 320e088d0b28ba57648586314a23d9f011b61a72..29f5068f819b604b61a8a5b542ff3acbe70cc200 100644 (file)
@@ -1388,8 +1388,7 @@ void __init inode_init(unsigned long mempages)
                                         0,
                                         (SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|
                                         SLAB_MEM_SPREAD),
-                                        init_once,
-                                        NULL);
+                                        init_once);
        register_shrinker(&icache_shrinker);
 
        /* Hash may have been set up in inode_init_early */
index 9f2224f65a18b9df2831ce2d71365f0c283c47b9..9bf2f6c09df64932bba2f88e838a240f7e4e2eea 100644 (file)
@@ -716,10 +716,10 @@ static int __init inotify_user_setup(void)
 
        watch_cachep = kmem_cache_create("inotify_watch_cache",
                                         sizeof(struct inotify_user_watch),
-                                        0, SLAB_PANIC, NULL, NULL);
+                                        0, SLAB_PANIC, NULL);
        event_cachep = kmem_cache_create("inotify_event_cache",
                                         sizeof(struct inotify_kernel_event),
-                                        0, SLAB_PANIC, NULL, NULL);
+                                        0, SLAB_PANIC, NULL);
 
        return 0;
 }
index 4f5418be0590ed6d484fd628a31fc65c9c7bea71..95c72aa818677b9ced909477aa80deedbd9232bb 100644 (file)
@@ -86,7 +86,7 @@ static int init_inodecache(void)
                                        sizeof(struct iso_inode_info),
                                        0, (SLAB_RECLAIM_ACCOUNT|
                                        SLAB_MEM_SPREAD),
-                                       init_once, NULL);
+                                       init_once);
        if (isofs_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 46fe7439fb919b6c602e8e751e33cc42e94c1b8e..06ab3c10b1b894af6cc03210a82c08f137c96024 100644 (file)
@@ -1668,7 +1668,7 @@ static int journal_create_jbd_slab(size_t slab_size)
         * boundary.
         */
        jbd_slab[i] = kmem_cache_create(jbd_slab_names[i],
-                               slab_size, slab_size, 0, NULL, NULL);
+                               slab_size, slab_size, 0, NULL);
        if (!jbd_slab[i]) {
                printk(KERN_EMERG "JBD: no memory for jbd_slab cache\n");
                return -ENOMEM;
@@ -1711,8 +1711,7 @@ static int journal_init_journal_head_cache(void)
                                sizeof(struct journal_head),
                                0,              /* offset */
                                0,              /* flags */
-                               NULL,           /* ctor */
-                               NULL);          /* dtor */
+                               NULL);          /* ctor */
        retval = 0;
        if (journal_head_cache == 0) {
                retval = -ENOMEM;
@@ -2008,8 +2007,7 @@ static int __init journal_init_handle_cache(void)
                                sizeof(handle_t),
                                0,              /* offset */
                                0,              /* flags */
-                               NULL,           /* ctor */
-                               NULL);          /* dtor */
+                               NULL);          /* ctor */
        if (jbd_handle_cache == NULL) {
                printk(KERN_EMERG "JBD: failed to create handle cache\n");
                return -ENOMEM;
index 8db2fa25170b7ae55cfd6625ec78fca127920578..62e13c8db132b5efc4ec24adcfb3837204cf0014 100644 (file)
@@ -170,13 +170,13 @@ int __init journal_init_revoke_caches(void)
 {
        revoke_record_cache = kmem_cache_create("revoke_record",
                                           sizeof(struct jbd_revoke_record_s),
-                                          0, SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                          0, SLAB_HWCACHE_ALIGN, NULL);
        if (revoke_record_cache == 0)
                return -ENOMEM;
 
        revoke_table_cache = kmem_cache_create("revoke_table",
                                           sizeof(struct jbd_revoke_table_s),
-                                          0, 0, NULL, NULL);
+                                          0, 0, NULL);
        if (revoke_table_cache == 0) {
                kmem_cache_destroy(revoke_record_cache);
                revoke_record_cache = NULL;
index f290cb7cb83454e5e2814b0746c0e2a9507b7aed..f37324aee817c9181fee667ba334c9df293f8666 100644 (file)
@@ -1680,7 +1680,7 @@ static int jbd2_journal_create_jbd_slab(size_t slab_size)
         * boundary.
         */
        jbd_slab[i] = kmem_cache_create(jbd_slab_names[i],
-                               slab_size, slab_size, 0, NULL, NULL);
+                               slab_size, slab_size, 0, NULL);
        if (!jbd_slab[i]) {
                printk(KERN_EMERG "JBD: no memory for jbd_slab cache\n");
                return -ENOMEM;
@@ -1723,8 +1723,7 @@ static int journal_init_jbd2_journal_head_cache(void)
                                sizeof(struct journal_head),
                                0,              /* offset */
                                0,              /* flags */
-                               NULL,           /* ctor */
-                               NULL);          /* dtor */
+                               NULL);          /* ctor */
        retval = 0;
        if (jbd2_journal_head_cache == 0) {
                retval = -ENOMEM;
@@ -2006,8 +2005,7 @@ static int __init journal_init_handle_cache(void)
                                sizeof(handle_t),
                                0,              /* offset */
                                0,              /* flags */
-                               NULL,           /* ctor */
-                               NULL);          /* dtor */
+                               NULL);          /* ctor */
        if (jbd2_handle_cache == NULL) {
                printk(KERN_EMERG "JBD: failed to create handle cache\n");
                return -ENOMEM;
index 28cac049a56bfafebb7714389576aabdd2d52e17..01d88975e0c5641101921ef8e0901fd631446c78 100644 (file)
@@ -171,13 +171,13 @@ int __init jbd2_journal_init_revoke_caches(void)
 {
        jbd2_revoke_record_cache = kmem_cache_create("jbd2_revoke_record",
                                           sizeof(struct jbd2_revoke_record_s),
-                                          0, SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                          0, SLAB_HWCACHE_ALIGN, NULL);
        if (jbd2_revoke_record_cache == 0)
                return -ENOMEM;
 
        jbd2_revoke_table_cache = kmem_cache_create("jbd2_revoke_table",
                                           sizeof(struct jbd2_revoke_table_s),
-                                          0, 0, NULL, NULL);
+                                          0, 0, NULL);
        if (jbd2_revoke_table_cache == 0) {
                kmem_cache_destroy(jbd2_revoke_record_cache);
                jbd2_revoke_record_cache = NULL;
index 35c1a5e30ba1b279d4e596531cdfe2d6ceea2021..f9211252b5f16f424fda655a0e5881680fc8eb78 100644 (file)
@@ -33,56 +33,56 @@ int __init jffs2_create_slab_caches(void)
 {
        full_dnode_slab = kmem_cache_create("jffs2_full_dnode",
                                            sizeof(struct jffs2_full_dnode),
-                                           0, 0, NULL, NULL);
+                                           0, 0, NULL);
        if (!full_dnode_slab)
                goto err;
 
        raw_dirent_slab = kmem_cache_create("jffs2_raw_dirent",
                                            sizeof(struct jffs2_raw_dirent),
-                                           0, 0, NULL, NULL);
+                                           0, 0, NULL);
        if (!raw_dirent_slab)
                goto err;
 
        raw_inode_slab = kmem_cache_create("jffs2_raw_inode",
                                           sizeof(struct jffs2_raw_inode),
-                                          0, 0, NULL, NULL);
+                                          0, 0, NULL);
        if (!raw_inode_slab)
                goto err;
 
        tmp_dnode_info_slab = kmem_cache_create("jffs2_tmp_dnode",
                                                sizeof(struct jffs2_tmp_dnode_info),
-                                               0, 0, NULL, NULL);
+                                               0, 0, NULL);
        if (!tmp_dnode_info_slab)
                goto err;
 
        raw_node_ref_slab = kmem_cache_create("jffs2_refblock",
                                              sizeof(struct jffs2_raw_node_ref) * (REFS_PER_BLOCK + 1),
-                                             0, 0, NULL, NULL);
+                                             0, 0, NULL);
        if (!raw_node_ref_slab)
                goto err;
 
        node_frag_slab = kmem_cache_create("jffs2_node_frag",
                                           sizeof(struct jffs2_node_frag),
-                                          0, 0, NULL, NULL);
+                                          0, 0, NULL);
        if (!node_frag_slab)
                goto err;
 
        inode_cache_slab = kmem_cache_create("jffs2_inode_cache",
                                             sizeof(struct jffs2_inode_cache),
-                                            0, 0, NULL, NULL);
+                                            0, 0, NULL);
        if (!inode_cache_slab)
                goto err;
 
 #ifdef CONFIG_JFFS2_FS_XATTR
        xattr_datum_cache = kmem_cache_create("jffs2_xattr_datum",
                                             sizeof(struct jffs2_xattr_datum),
-                                            0, 0, NULL, NULL);
+                                            0, 0, NULL);
        if (!xattr_datum_cache)
                goto err;
 
        xattr_ref_cache = kmem_cache_create("jffs2_xattr_ref",
                                           sizeof(struct jffs2_xattr_ref),
-                                          0, 0, NULL, NULL);
+                                          0, 0, NULL);
        if (!xattr_ref_cache)
                goto err;
 #endif
index e220d3bd610de5ae2bc3eb96441d0c9c3c1c8d28..be2b70c2ec1653890df1c08aae864293e47a6b50 100644 (file)
@@ -192,7 +192,7 @@ static int __init init_jffs2_fs(void)
                                             sizeof(struct jffs2_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            jffs2_i_init_once, NULL);
+                                            jffs2_i_init_once);
        if (!jffs2_inode_cachep) {
                printk(KERN_ERR "JFFS2 error: Failed to initialise inode cache\n");
                return -ENOMEM;
index 77c7f1129dde636e734f6e354218c72eff5ed0d9..62e96be02acfcdfa87c15e9ce63a8ff1643ad18e 100644 (file)
@@ -213,7 +213,7 @@ int __init metapage_init(void)
         * Allocate the metapage structures
         */
        metapage_cache = kmem_cache_create("jfs_mp", sizeof(struct metapage),
-                                          0, 0, init_once, NULL);
+                                          0, 0, init_once);
        if (metapage_cache == NULL)
                return -ENOMEM;
 
index 929fceca7999bb643db1d07fec125d154ad87199..4b372f550652686f5202af80e481f948ba3dba20 100644 (file)
@@ -776,7 +776,7 @@ static int __init init_jfs_fs(void)
        jfs_inode_cachep =
            kmem_cache_create("jfs_ip", sizeof(struct jfs_inode_info), 0,
                            SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
-                           init_once, NULL);
+                           init_once);
        if (jfs_inode_cachep == NULL)
                return -ENOMEM;
 
index 4f2d749ac624f6315f947c4e44513d170ac23e14..31051063724786e0780dad4183f72544995f0763 100644 (file)
@@ -2276,7 +2276,7 @@ static int __init filelock_init(void)
 {
        filelock_cache = kmem_cache_create("file_lock_cache",
                        sizeof(struct file_lock), 0, SLAB_PANIC,
-                       init_once, NULL);
+                       init_once);
        return 0;
 }
 
index fbb1d02f8791531a0386887aeec7b21b6fa1563f..1046cbefbfbf4f56be9640dacacc1d884af492f4 100644 (file)
@@ -292,7 +292,7 @@ mb_cache_create(const char *name, struct mb_cache_op *cache_op,
                        INIT_LIST_HEAD(&cache->c_indexes_hash[m][n]);
        }
        cache->c_entry_cache = kmem_cache_create(name, entry_size, 0,
-               SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL, NULL);
+               SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL);
        if (!cache->c_entry_cache)
                goto fail;
 
index be4044614ac83374672d90cacb406aee004375ee..43668d7d668fd40e909fcd7ed6146a66bdd00e3b 100644 (file)
@@ -75,14 +75,14 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 
        inode_init_once(&ei->vfs_inode);
 }
+
 static int init_inodecache(void)
 {
        minix_inode_cachep = kmem_cache_create("minix_inode_cache",
                                             sizeof(struct minix_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (minix_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 4198003d7e18a79228ebf5a8a7f9d06cca86be21..ddbda13c2d317dc79bb6bffa41e688a250dd1ccf 100644 (file)
@@ -1801,7 +1801,7 @@ void __init mnt_init(unsigned long mempages)
        init_rwsem(&namespace_sem);
 
        mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct vfsmount),
-                       0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL, NULL);
+                       0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
 
        mount_hashtable = (struct list_head *)__get_free_page(GFP_ATOMIC);
 
index cf06eb9f050e31db04c2852832471358a790272c..7f8536dbdedcfeb794d716539aa33cefc9b93e8d 100644 (file)
@@ -63,14 +63,14 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
        mutex_init(&ei->open_mutex);
        inode_init_once(&ei->vfs_inode);
 }
+
 static int init_inodecache(void)
 {
        ncp_inode_cachep = kmem_cache_create("ncp_inode_cache",
                                             sizeof(struct ncp_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (ncp_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index a5c82b6f3b4556918aa169da26ce43c45c4a6f00..fcf4d384610e1a916cebf2f5c9c3f958f8c54b0b 100644 (file)
@@ -875,7 +875,7 @@ int __init nfs_init_directcache(void)
                                                sizeof(struct nfs_direct_req),
                                                0, (SLAB_RECLAIM_ACCOUNT|
                                                        SLAB_MEM_SPREAD),
-                                               NULL, NULL);
+                                               NULL);
        if (nfs_direct_cachep == NULL)
                return -ENOMEM;
 
index 3d9fccf4ef93eb9f51c01f2fa7d3e435ca881216..bca6cdcb9f0dd738a4bb5f6d07d0b27f5a72c3a2 100644 (file)
@@ -1165,14 +1165,14 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
        nfsi->npages = 0;
        nfs4_init_once(nfsi);
 }
+
 static int __init nfs_init_inodecache(void)
 {
        nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
                                             sizeof(struct nfs_inode),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (nfs_inode_cachep == NULL)
                return -ENOMEM;
 
index f56dae5216f4dfadd82bc316a439487c8fd2cc72..345bb9b4765b6fee52fd8a0c76558c34e2fc1f1c 100644 (file)
@@ -442,7 +442,7 @@ int __init nfs_init_nfspagecache(void)
        nfs_page_cachep = kmem_cache_create("nfs_page",
                                            sizeof(struct nfs_page),
                                            0, SLAB_HWCACHE_ALIGN,
-                                           NULL, NULL);
+                                           NULL);
        if (nfs_page_cachep == NULL)
                return -ENOMEM;
 
index 6ae2e58ed05af3620888a412e2abcee8a5c8bd9d..19e05633f4e3463152b2867fcc2ac3f13e933b96 100644 (file)
@@ -598,7 +598,7 @@ int __init nfs_init_readpagecache(void)
        nfs_rdata_cachep = kmem_cache_create("nfs_read_data",
                                             sizeof(struct nfs_read_data),
                                             0, SLAB_HWCACHE_ALIGN,
-                                            NULL, NULL);
+                                            NULL);
        if (nfs_rdata_cachep == NULL)
                return -ENOMEM;
 
index 73ac992ece85d2c33a1b02c368fe917110c63410..ef97e0c0f5b1a24d6fc338e6f9aeeae5f5819b46 100644 (file)
@@ -1467,7 +1467,7 @@ int __init nfs_init_writepagecache(void)
        nfs_wdata_cachep = kmem_cache_create("nfs_write_data",
                                             sizeof(struct nfs_write_data),
                                             0, SLAB_HWCACHE_ALIGN,
-                                            NULL, NULL);
+                                            NULL);
        if (nfs_wdata_cachep == NULL)
                return -ENOMEM;
 
index 6284807bd37e588906417d55715067ddf9722247..3f559700788f1603a60840ce7bfc3b20e857fd48 100644 (file)
@@ -1032,19 +1032,19 @@ static int
 nfsd4_init_slabs(void)
 {
        stateowner_slab = kmem_cache_create("nfsd4_stateowners",
-                       sizeof(struct nfs4_stateowner), 0, 0, NULL, NULL);
+                       sizeof(struct nfs4_stateowner), 0, 0, NULL);
        if (stateowner_slab == NULL)
                goto out_nomem;
        file_slab = kmem_cache_create("nfsd4_files",
-                       sizeof(struct nfs4_file), 0, 0, NULL, NULL);
+                       sizeof(struct nfs4_file), 0, 0, NULL);
        if (file_slab == NULL)
                goto out_nomem;
        stateid_slab = kmem_cache_create("nfsd4_stateids",
-                       sizeof(struct nfs4_stateid), 0, 0, NULL, NULL);
+                       sizeof(struct nfs4_stateid), 0, 0, NULL);
        if (stateid_slab == NULL)
                goto out_nomem;
        deleg_slab = kmem_cache_create("nfsd4_delegations",
-                       sizeof(struct nfs4_delegation), 0, 0, NULL, NULL);
+                       sizeof(struct nfs4_delegation), 0, 0, NULL);
        if (deleg_slab == NULL)
                goto out_nomem;
        return 0;
index 4566b9182551cdaf004a5057e1311b9c5eb86b49..90c4e3a29706c1210ccce4d9d94dc37e3df0659d 100644 (file)
@@ -3143,7 +3143,7 @@ static int __init init_ntfs_fs(void)
 
        ntfs_index_ctx_cache = kmem_cache_create(ntfs_index_ctx_cache_name,
                        sizeof(ntfs_index_context), 0 /* offset */,
-                       SLAB_HWCACHE_ALIGN, NULL /* ctor */, NULL /* dtor */);
+                       SLAB_HWCACHE_ALIGN, NULL /* ctor */);
        if (!ntfs_index_ctx_cache) {
                printk(KERN_CRIT "NTFS: Failed to create %s!\n",
                                ntfs_index_ctx_cache_name);
@@ -3151,7 +3151,7 @@ static int __init init_ntfs_fs(void)
        }
        ntfs_attr_ctx_cache = kmem_cache_create(ntfs_attr_ctx_cache_name,
                        sizeof(ntfs_attr_search_ctx), 0 /* offset */,
-                       SLAB_HWCACHE_ALIGN, NULL /* ctor */, NULL /* dtor */);
+                       SLAB_HWCACHE_ALIGN, NULL /* ctor */);
        if (!ntfs_attr_ctx_cache) {
                printk(KERN_CRIT "NTFS: Failed to create %s!\n",
                                ntfs_attr_ctx_cache_name);
@@ -3160,7 +3160,7 @@ static int __init init_ntfs_fs(void)
 
        ntfs_name_cache = kmem_cache_create(ntfs_name_cache_name,
                        (NTFS_MAX_NAME_LEN+1) * sizeof(ntfschar), 0,
-                       SLAB_HWCACHE_ALIGN, NULL, NULL);
+                       SLAB_HWCACHE_ALIGN, NULL);
        if (!ntfs_name_cache) {
                printk(KERN_CRIT "NTFS: Failed to create %s!\n",
                                ntfs_name_cache_name);
@@ -3169,7 +3169,7 @@ static int __init init_ntfs_fs(void)
 
        ntfs_inode_cache = kmem_cache_create(ntfs_inode_cache_name,
                        sizeof(ntfs_inode), 0,
-                       SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL, NULL);
+                       SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL);
        if (!ntfs_inode_cache) {
                printk(KERN_CRIT "NTFS: Failed to create %s!\n",
                                ntfs_inode_cache_name);
@@ -3179,7 +3179,7 @@ static int __init init_ntfs_fs(void)
        ntfs_big_inode_cache = kmem_cache_create(ntfs_big_inode_cache_name,
                        sizeof(big_ntfs_inode), 0,
                        SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
-                       ntfs_big_inode_init_once, NULL);
+                       ntfs_big_inode_init_once);
        if (!ntfs_big_inode_cache) {
                printk(KERN_CRIT "NTFS: Failed to create %s!\n",
                                ntfs_big_inode_cache_name);
index fd8cb1badc9b9db082219a170f8240c3675cf72a..7418dc83de1c050039aa2b53719fc96ac3129437 100644 (file)
@@ -592,7 +592,7 @@ static int __init init_dlmfs_fs(void)
                                sizeof(struct dlmfs_inode_private),
                                0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
                                        SLAB_MEM_SPREAD),
-                               dlmfs_init_once, NULL);
+                               dlmfs_init_once);
        if (!dlmfs_inode_cache)
                return -ENOMEM;
        cleanup_inode = 1;
index 65b2b9b9268854001da953a26720afbead6fc154..62e4a7daa286d86daf1f58d6f092c80e4149f1f0 100644 (file)
@@ -510,7 +510,7 @@ int dlm_init_mle_cache(void)
        dlm_mle_cache = kmem_cache_create("dlm_mle_cache",
                                          sizeof(struct dlm_master_list_entry),
                                          0, SLAB_HWCACHE_ALIGN,
-                                         NULL, NULL);
+                                         NULL);
        if (dlm_mle_cache == NULL)
                return -ENOMEM;
        return 0;
index 3a5a1ed09ac906ab94b0dd14897fdbaf4d843284..200c7d4790dc187a7a6e60b30ff4a36b9f55cc59 100644 (file)
@@ -984,7 +984,7 @@ static int ocfs2_initialize_mem_caches(void)
                                       0,
                                       (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                      ocfs2_inode_init_once, NULL);
+                                      ocfs2_inode_init_once);
        if (!ocfs2_inode_cachep)
                return -ENOMEM;
 
index 39814b900fc0dda863895768dda78e1ab64afa45..4da8851f2b23af737df164d0ec64133117f19508 100644 (file)
@@ -548,7 +548,7 @@ int __init init_ocfs2_uptodate_cache(void)
 {
        ocfs2_uptodate_cachep = kmem_cache_create("ocfs2_uptodate",
                                  sizeof(struct ocfs2_meta_cache_item),
-                                 0, SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                 0, SLAB_HWCACHE_ALIGN, NULL);
        if (!ocfs2_uptodate_cachep)
                return -ENOMEM;
 
index e62397341c363fa31bbc656cd59120320786a55d..dd86be2aa6c922b0bc4ec0407fa4effd8c50be2c 100644 (file)
@@ -431,7 +431,7 @@ static int __init init_openprom_fs(void)
                                            0,
                                            (SLAB_RECLAIM_ACCOUNT |
                                             SLAB_MEM_SPREAD),
-                                           op_inode_init_once, NULL);
+                                           op_inode_init_once);
        if (!op_inode_cachep)
                return -ENOMEM;
 
index dd28e86ab422fe23e06969cebf14c3677a6c8902..94e2c1adf184f157413fe9d91def4a0e447850ea 100644 (file)
@@ -112,14 +112,14 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 
        inode_init_once(&ei->vfs_inode);
 }
+
 int __init proc_init_inodecache(void)
 {
        proc_inode_cachep = kmem_cache_create("proc_inode_cache",
                                             sizeof(struct proc_inode),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (proc_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 8d256eb118130130b5738f278114f9424f381e86..1bc8d873a9e17ff20cfa7e550ed3b947ca87500a 100644 (file)
@@ -545,7 +545,7 @@ static int init_inodecache(void)
                                             sizeof(struct qnx4_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (qnx4_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 5a93cfe1a0326eba2ef8872f67ae72eedbdf5f0a..5b68dd3f191a41789887a1fb0651eceee50527f1 100644 (file)
@@ -527,7 +527,7 @@ static int init_inodecache(void)
                                                         reiserfs_inode_info),
                                                  0, (SLAB_RECLAIM_ACCOUNT|
                                                        SLAB_MEM_SPREAD),
-                                                 init_once, NULL);
+                                                 init_once);
        if (reiserfs_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 2284e03342c6af7367d9fb602732f709cba98d48..dae7945f90e4e9aee698a4d06008eb41d7dd2e2a 100644 (file)
@@ -572,14 +572,14 @@ static void init_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
 
        inode_init_once(&ei->vfs_inode);
 }
+
 static int init_inodecache(void)
 {
        romfs_inode_cachep = kmem_cache_create("romfs_inode_cache",
                                             sizeof(struct romfs_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (romfs_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 6724a6cf01ff49be7b21315d1e19695d43cc4682..73d1450a95d4233357650af9b99359cf56dab217 100644 (file)
@@ -73,14 +73,14 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 
        inode_init_once(&ei->vfs_inode);
 }
+
 static int init_inodecache(void)
 {
        smb_inode_cachep = kmem_cache_create("smb_inode_cache",
                                             sizeof(struct smb_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (smb_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 3f54a0f80fae45533316b0e618c99981eb77220f..ca4b2d59c0ca6f501ff11466af81a6111a182afc 100644 (file)
@@ -40,7 +40,7 @@ int smb_init_request_cache(void)
        req_cachep = kmem_cache_create("smb_request",
                                       sizeof(struct smb_request), 0,
                                       SMB_SLAB_DEBUG | SLAB_HWCACHE_ALIGN,
-                                      NULL, NULL);
+                                      NULL);
        if (req_cachep == NULL)
                return -ENOMEM;
 
index 60714d075c2fc0911c0189ea25ade5ac245b9255..fbc7b65fe26267d776a105f5d37f01627edf44a2 100644 (file)
@@ -86,7 +86,7 @@ int __init sysfs_init(void)
 
        sysfs_dir_cachep = kmem_cache_create("sysfs_dir_cache",
                                              sizeof(struct sysfs_dirent),
-                                             0, 0, NULL, NULL);
+                                             0, 0, NULL);
        if (!sysfs_dir_cachep)
                goto out;
 
index 564411693394581a51ad421b78bfd7e54bbdc658..7c4e5d302abb937d3cdbe4903ff52bf941a5a6d3 100644 (file)
@@ -342,7 +342,7 @@ int __init sysv_init_icache(void)
        sysv_inode_cachep = kmem_cache_create("sysv_inode_cache",
                        sizeof(struct sysv_inode_info), 0,
                        SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
-                       init_once, NULL);
+                       init_once);
        if (!sysv_inode_cachep)
                return -ENOMEM;
        return 0;
index 911387aa181019f943509b535e5ae21028651177..72097ee6b75284c6d3b06a3cf90084a918052ee3 100644 (file)
@@ -149,7 +149,7 @@ static int init_inodecache(void)
                                             sizeof(struct udf_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT |
                                                 SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (udf_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 2b3011689e89e4aff651b3f3f8ca05775d3d4a78..73402c5eeb8afc90452768b57f0cbdb13fcc3469 100644 (file)
@@ -1240,14 +1240,14 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
 
        inode_init_once(&ei->vfs_inode);
 }
+
 static int init_inodecache(void)
 {
        ufs_inode_cachep = kmem_cache_create("ufs_inode_cache",
                                             sizeof(struct ufs_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                                            init_once, NULL);
+                                            init_once);
        if (ufs_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 4b6470cf87f0c633c3ca1b0bbe4d98ffb2757374..b4acc7f3c3744dbb96f91eeac484c58dcddc2aff 100644 (file)
@@ -74,14 +74,14 @@ extern void  kmem_free(void *, size_t);
 static inline kmem_zone_t *
 kmem_zone_init(int size, char *zone_name)
 {
-       return kmem_cache_create(zone_name, size, 0, 0, NULL, NULL);
+       return kmem_cache_create(zone_name, size, 0, 0, NULL);
 }
 
 static inline kmem_zone_t *
 kmem_zone_init_flags(int size, char *zone_name, unsigned long flags,
                     void (*construct)(void *, kmem_zone_t *, unsigned long))
 {
-       return kmem_cache_create(zone_name, size, 0, flags, construct, NULL);
+       return kmem_cache_create(zone_name, size, 0, flags, construct);
 }
 
 static inline void
index 333a370a3bdce0d2f6603ab90d01cf455ad49c84..9752307d16ba1569b904380d0e9d360625da1e49 100644 (file)
@@ -946,8 +946,7 @@ static inline int i2o_pool_alloc(struct i2o_pool *pool, const char *name,
        strcpy(pool->name, name);
 
        pool->slab =
-           kmem_cache_create(pool->name, size, 0, SLAB_HWCACHE_ALIGN, NULL,
-                             NULL);
+           kmem_cache_create(pool->name, size, 0, SLAB_HWCACHE_ALIGN, NULL);
        if (!pool->slab)
                goto free_name;
 
index 0e1d0daef6a21fa843bff7e40d406f961b36c776..7d0ecc1659f063df2f69550aa3d3b157cd36f1fd 100644 (file)
@@ -51,7 +51,6 @@ int slab_is_available(void);
 
 struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
                        unsigned long,
-                       void (*)(void *, struct kmem_cache *, unsigned long),
                        void (*)(void *, struct kmem_cache *, unsigned long));
 void kmem_cache_destroy(struct kmem_cache *);
 int kmem_cache_shrink(struct kmem_cache *);
@@ -70,7 +69,7 @@ int kmem_ptr_validate(struct kmem_cache *cachep, const void *ptr);
  */
 #define KMEM_CACHE(__struct, __flags) kmem_cache_create(#__struct,\
                sizeof(struct __struct), __alignof__(struct __struct),\
-               (__flags), NULL, NULL)
+               (__flags), NULL)
 
 /*
  * The largest kmalloc size supported by the slab allocators is
index a242c83d89d604a364fb447a66e59d47856478e0..145d5a0d299f77d8cb328b9deb292f55c69f5a7d 100644 (file)
@@ -1253,7 +1253,7 @@ static int __init init_mqueue_fs(void)
 
        mqueue_inode_cachep = kmem_cache_create("mqueue_inode_cache",
                                sizeof(struct mqueue_inode_info), 0,
-                               SLAB_HWCACHE_ALIGN, init_once, NULL);
+                               SLAB_HWCACHE_ALIGN, init_once);
        if (mqueue_inode_cachep == NULL)
                return -ENOMEM;
 
index 469838998220bb58a261c60f47c86c4b6165ac95..7332e236d3676153dc9f40c1a78848e6e2810632 100644 (file)
@@ -137,7 +137,7 @@ void __init fork_init(unsigned long mempages)
        /* create a slab on which task_structs can be allocated */
        task_struct_cachep =
                kmem_cache_create("task_struct", sizeof(struct task_struct),
-                       ARCH_MIN_TASKALIGN, SLAB_PANIC, NULL, NULL);
+                       ARCH_MIN_TASKALIGN, SLAB_PANIC, NULL);
 #endif
 
        /*
@@ -1446,22 +1446,22 @@ void __init proc_caches_init(void)
        sighand_cachep = kmem_cache_create("sighand_cache",
                        sizeof(struct sighand_struct), 0,
                        SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU,
-                       sighand_ctor, NULL);
+                       sighand_ctor);
        signal_cachep = kmem_cache_create("signal_cache",
                        sizeof(struct signal_struct), 0,
-                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
-       files_cachep = kmem_cache_create("files_cache", 
+                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
+       files_cachep = kmem_cache_create("files_cache",
                        sizeof(struct files_struct), 0,
-                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
-       fs_cachep = kmem_cache_create("fs_cache", 
+                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
+       fs_cachep = kmem_cache_create("fs_cache",
                        sizeof(struct fs_struct), 0,
-                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
        vm_area_cachep = kmem_cache_create("vm_area_struct",
                        sizeof(struct vm_area_struct), 0,
-                       SLAB_PANIC, NULL, NULL);
+                       SLAB_PANIC, NULL);
        mm_cachep = kmem_cache_create("mm_struct",
                        sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,
-                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                       SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 }
 
 /*
index 10f0bbba382bed8c37d498cd55cf5871eb9b8bd4..a4fb7d46971f48a8655ba8e5087025593cf6e79e 100644 (file)
@@ -193,7 +193,7 @@ int unshare_nsproxy_namespaces(unsigned long unshare_flags,
 static int __init nsproxy_cache_init(void)
 {
        nsproxy_cachep = kmem_cache_create("nsproxy", sizeof(struct nsproxy),
-                                          0, SLAB_PANIC, NULL, NULL);
+                                          0, SLAB_PANIC, NULL);
        return 0;
 }
 
index 329ce0172074a8270b662e3850118d08d42c0dc0..55b3761edaa9afe42273a7b3adaa42b1547fb5ee 100644 (file)
@@ -241,7 +241,7 @@ static __init int init_posix_timers(void)
        register_posix_clock(CLOCK_MONOTONIC, &clock_monotonic);
 
        posix_timers_cache = kmem_cache_create("posix_timers_cache",
-                                       sizeof (struct k_itimer), 0, 0, NULL, NULL);
+                                       sizeof (struct k_itimer), 0, 0, NULL);
        idr_init(&posix_timers_id);
        return 0;
 }
index 98b82507797a9f26fd0a2d4ee3d9d22d92928c08..e7d11cef6998fdb378506d72232c4041738dce2f 100644 (file)
@@ -208,7 +208,7 @@ static int __init uid_cache_init(void)
        int n;
 
        uid_cachep = kmem_cache_create("uid_cache", sizeof(struct user_struct),
-                       0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                       0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 
        for(n = 0; n < UIDHASH_SZ; ++n)
                INIT_LIST_HEAD(init_user_ns.uidhash_table + n);
index 5ca67b3cfd35ba3243badf0fc50371c299c961fd..ffd61941e75d805460af6efd6944b06b839eafea 100644 (file)
--- a/lib/idr.c
+++ b/lib/idr.c
@@ -590,7 +590,7 @@ static  int init_id_cache(void)
 {
        if (!idr_layer_cache)
                idr_layer_cache = kmem_cache_create("idr_layer_cache",
-                       sizeof(struct idr_layer), 0, 0, idr_cache_ctor, NULL);
+                       sizeof(struct idr_layer), 0, 0, idr_cache_ctor);
        return 0;
 }
 
index 9927cca14cb70fd0d65a9ca63c297258dfebdc87..514efb200be6775dd57633a71987a7dcfe2b9ee9 100644 (file)
@@ -1021,7 +1021,7 @@ void __init radix_tree_init(void)
 {
        radix_tree_node_cachep = kmem_cache_create("radix_tree_node",
                        sizeof(struct radix_tree_node), 0,
-                       SLAB_PANIC, radix_tree_node_ctor, NULL);
+                       SLAB_PANIC, radix_tree_node_ctor);
        radix_tree_init_maxindex();
        hotcpu_notifier(radix_tree_callback, 0);
 }
index 9f4e9b95e8f2238597f88b362221527160bf98f9..71b84b45154afc59efa6e0ffd3f088603693417a 100644 (file)
@@ -1605,11 +1605,11 @@ void __init numa_policy_init(void)
 
        policy_cache = kmem_cache_create("numa_policy",
                                         sizeof(struct mempolicy),
-                                        0, SLAB_PANIC, NULL, NULL);
+                                        0, SLAB_PANIC, NULL);
 
        sn_cache = kmem_cache_create("shared_policy_node",
                                     sizeof(struct sp_node),
-                                    0, SLAB_PANIC, NULL, NULL);
+                                    0, SLAB_PANIC, NULL);
 
        /*
         * Set interleaving policy for system init. Interleaving is only
index fede5c7910beebe57894af31a37db9cb8fc8dee4..41ac39749ef42af4b7b6bb173372fb081f39735a 100644 (file)
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -149,7 +149,7 @@ static void anon_vma_ctor(void *data, struct kmem_cache *cachep,
 void __init anon_vma_init(void)
 {
        anon_vma_cachep = kmem_cache_create("anon_vma", sizeof(struct anon_vma),
-                       0, SLAB_DESTROY_BY_RCU|SLAB_PANIC, anon_vma_ctor, NULL);
+                       0, SLAB_DESTROY_BY_RCU|SLAB_PANIC, anon_vma_ctor);
 }
 
 /*
index ad155c7745dc679252957b8df44461ba0f959d2b..fcd19d323f9f68079f92c4899218411f4f97d50b 100644 (file)
@@ -2322,7 +2322,7 @@ static int init_inodecache(void)
 {
        shmem_inode_cachep = kmem_cache_create("shmem_inode_cache",
                                sizeof(struct shmem_inode_info),
-                               0, 0, init_once, NULL);
+                               0, 0, init_once);
        if (shmem_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index c3feeaab387537ef00aa2085b4f54f6d7e4abca0..bde271c001ba33ef1f61dd0f563f74d319cd1f0e 100644 (file)
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -1484,7 +1484,7 @@ void __init kmem_cache_init(void)
                                        sizes[INDEX_AC].cs_size,
                                        ARCH_KMALLOC_MINALIGN,
                                        ARCH_KMALLOC_FLAGS|SLAB_PANIC,
-                                       NULL, NULL);
+                                       NULL);
 
        if (INDEX_AC != INDEX_L3) {
                sizes[INDEX_L3].cs_cachep =
@@ -1492,7 +1492,7 @@ void __init kmem_cache_init(void)
                                sizes[INDEX_L3].cs_size,
                                ARCH_KMALLOC_MINALIGN,
                                ARCH_KMALLOC_FLAGS|SLAB_PANIC,
-                               NULL, NULL);
+                               NULL);
        }
 
        slab_early_init = 0;
@@ -1510,7 +1510,7 @@ void __init kmem_cache_init(void)
                                        sizes->cs_size,
                                        ARCH_KMALLOC_MINALIGN,
                                        ARCH_KMALLOC_FLAGS|SLAB_PANIC,
-                                       NULL, NULL);
+                                       NULL);
                }
 #ifdef CONFIG_ZONE_DMA
                sizes->cs_dmacachep = kmem_cache_create(
@@ -1519,7 +1519,7 @@ void __init kmem_cache_init(void)
                                        ARCH_KMALLOC_MINALIGN,
                                        ARCH_KMALLOC_FLAGS|SLAB_CACHE_DMA|
                                                SLAB_PANIC,
-                                       NULL, NULL);
+                                       NULL);
 #endif
                sizes++;
                names++;
@@ -2101,12 +2101,10 @@ static int __init_refok setup_cpu_cache(struct kmem_cache *cachep)
  * @align: The required alignment for the objects.
  * @flags: SLAB flags
  * @ctor: A constructor for the objects.
- * @dtor: A destructor for the objects (not implemented anymore).
  *
  * Returns a ptr to the cache on success, NULL on failure.
  * Cannot be called within a int, but can be interrupted.
- * The @ctor is run when new pages are allocated by the cache
- * and the @dtor is run before the pages are handed back.
+ * The @ctor is run when new pages are allocated by the cache.
  *
  * @name must be valid until the cache is destroyed. This implies that
  * the module calling this has to destroy the cache before getting unloaded.
@@ -2126,8 +2124,7 @@ static int __init_refok setup_cpu_cache(struct kmem_cache *cachep)
 struct kmem_cache *
 kmem_cache_create (const char *name, size_t size, size_t align,
        unsigned long flags,
-       void (*ctor)(void*, struct kmem_cache *, unsigned long),
-       void (*dtor)(void*, struct kmem_cache *, unsigned long))
+       void (*ctor)(void*, struct kmem_cache *, unsigned long))
 {
        size_t left_over, slab_size, ralign;
        struct kmem_cache *cachep = NULL, *pc;
@@ -2136,7 +2133,7 @@ kmem_cache_create (const char *name, size_t size, size_t align,
         * Sanity checks... these are all serious usage bugs.
         */
        if (!name || in_interrupt() || (size < BYTES_PER_WORD) ||
-           size > KMALLOC_MAX_SIZE || dtor) {
+           size > KMALLOC_MAX_SIZE) {
                printk(KERN_ERR "%s: Early error in slab %s\n", __FUNCTION__,
                                name);
                BUG();
index c89ef116d7aaf99e48d564031c57a7a85dc45081..d50920ecc02bed44acc1dd3cdc2deed467b6b262 100644 (file)
--- a/mm/slob.c
+++ b/mm/slob.c
@@ -492,8 +492,7 @@ struct kmem_cache {
 
 struct kmem_cache *kmem_cache_create(const char *name, size_t size,
        size_t align, unsigned long flags,
-       void (*ctor)(void*, struct kmem_cache *, unsigned long),
-       void (*dtor)(void*, struct kmem_cache *, unsigned long))
+       void (*ctor)(void*, struct kmem_cache *, unsigned long))
 {
        struct kmem_cache *c;
 
index 322f3a5d72c702523a0a2834baea1d68dd67bb4d..9b2d6178d06ce7259941c6aafa7b20cf81228e40 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -2668,12 +2668,10 @@ static struct kmem_cache *find_mergeable(size_t size,
 
 struct kmem_cache *kmem_cache_create(const char *name, size_t size,
                size_t align, unsigned long flags,
-               void (*ctor)(void *, struct kmem_cache *, unsigned long),
-               void (*dtor)(void *, struct kmem_cache *, unsigned long))
+               void (*ctor)(void *, struct kmem_cache *, unsigned long))
 {
        struct kmem_cache *s;
 
-       BUG_ON(dtor);
        down_write(&slub_lock);
        s = find_mergeable(size, align, flags, ctor);
        if (s) {
index 3fc697293819524823ee8bb4d9918493f12db6e0..69b70977f00061610b30fc86475e167bf49f4ee0 100644 (file)
@@ -36,7 +36,7 @@ int __init br_fdb_init(void)
        br_fdb_cache = kmem_cache_create("bridge_fdb_cache",
                                         sizeof(struct net_bridge_fdb_entry),
                                         0,
-                                        SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                        SLAB_HWCACHE_ALIGN, NULL);
        if (!br_fdb_cache)
                return -ENOMEM;
 
index 051430545a05364bb9864df299c93130edaa626a..0ab5234b17d8423e18c20ac9575178b01b25b6a2 100644 (file)
@@ -350,7 +350,7 @@ static int __init flow_cache_init(void)
        flow_cachep = kmem_cache_create("flow_cache",
                                        sizeof(struct flow_cache_entry),
                                        0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                       NULL, NULL);
+                                       NULL);
        flow_hash_shift = 10;
        flow_lwm = 2 * flow_hash_size;
        flow_hwm = 4 * flow_hash_size;
index 9df26a07f0672ccabe610f366026fa4b2123524c..ca2a1533138a21dc6d19a8be243627774cbd2167 100644 (file)
@@ -1347,7 +1347,7 @@ void neigh_table_init_no_netlink(struct neigh_table *tbl)
                tbl->kmem_cachep =
                        kmem_cache_create(tbl->id, tbl->entry_size, 0,
                                          SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                         NULL, NULL);
+                                         NULL);
        tbl->stats = alloc_percpu(struct neigh_statistics);
        if (!tbl->stats)
                panic("cannot create neighbour cache statistics");
index 0583e8498f1351d2631024fd811ecdd1172da27c..35021eb3ed07a3767dabe38b1ad8312aa241798a 100644 (file)
@@ -2021,13 +2021,13 @@ void __init skb_init(void)
                                              sizeof(struct sk_buff),
                                              0,
                                              SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                             NULL, NULL);
+                                             NULL);
        skbuff_fclone_cache = kmem_cache_create("skbuff_fclone_cache",
                                                (2*sizeof(struct sk_buff)) +
                                                sizeof(atomic_t),
                                                0,
                                                SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                               NULL, NULL);
+                                               NULL);
 }
 
 /**
index 239a08a6ff2457fd134eb22472910af7a3026427..bd209c4477a9d2a150dd578206a3ad18e8653a38 100644 (file)
@@ -1767,7 +1767,7 @@ int proto_register(struct proto *prot, int alloc_slab)
 
        if (alloc_slab) {
                prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
-                                              SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                              SLAB_HWCACHE_ALIGN, NULL);
 
                if (prot->slab == NULL) {
                        printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
@@ -1785,7 +1785,7 @@ int proto_register(struct proto *prot, int alloc_slab)
                        sprintf(request_sock_slab_name, mask, prot->name);
                        prot->rsk_prot->slab = kmem_cache_create(request_sock_slab_name,
                                                                 prot->rsk_prot->obj_size, 0,
-                                                                SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                                                SLAB_HWCACHE_ALIGN, NULL);
 
                        if (prot->rsk_prot->slab == NULL) {
                                printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n",
@@ -1807,7 +1807,7 @@ int proto_register(struct proto *prot, int alloc_slab)
                                kmem_cache_create(timewait_sock_slab_name,
                                                  prot->twsk_prot->twsk_obj_size,
                                                  0, SLAB_HWCACHE_ALIGN,
-                                                 NULL, NULL);
+                                                 NULL);
                        if (prot->twsk_prot->twsk_slab == NULL)
                                goto out_free_timewait_sock_slab_name;
                }
index 01030f346177fc032da91459eee4d4d4a7d9dddf..7ac775f9a64b0f27cd2d05455dfe7420ea869faf 100644 (file)
@@ -481,14 +481,14 @@ int __init dccp_ackvec_init(void)
 {
        dccp_ackvec_slab = kmem_cache_create("dccp_ackvec",
                                             sizeof(struct dccp_ackvec), 0,
-                                            SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                            SLAB_HWCACHE_ALIGN, NULL);
        if (dccp_ackvec_slab == NULL)
                goto out_err;
 
        dccp_ackvec_record_slab =
                        kmem_cache_create("dccp_ackvec_record",
                                          sizeof(struct dccp_ackvec_record),
-                                         0, SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                         0, SLAB_HWCACHE_ALIGN, NULL);
        if (dccp_ackvec_record_slab == NULL)
                goto out_destroy_slab;
 
index d8cf92f09e68f1896519f2583eff815cbb6f4cfb..ccbf72c793b6c61381b40d466073a89f2bfb4575 100644 (file)
@@ -69,7 +69,7 @@ static struct kmem_cache *ccid_kmem_cache_create(int obj_size, const char *fmt,.
        if (slab_name == NULL)
                return NULL;
        slab = kmem_cache_create(slab_name, sizeof(struct ccid) + obj_size, 0,
-                                SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                SLAB_HWCACHE_ALIGN, NULL);
        if (slab == NULL)
                kfree(slab_name);
        return slab;
index dd0fc992b042beafd80340e3d87178add3756ee2..174d3f13d93f733bc0322d9283c82a14a72fd57e 100644 (file)
@@ -282,7 +282,7 @@ static __init int dccp_li_init(void)
 {
        dccp_li_cachep = kmem_cache_create("dccp_li_hist",
                                           sizeof(struct dccp_li_hist_entry),
-                                          0, SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                          0, SLAB_HWCACHE_ALIGN, NULL);
        return dccp_li_cachep == NULL ? -ENOBUFS : 0;
 }
 
index 2e8ef42721e264e5f06149c21d7d6aa631d15552..34c4f60477248de941d92fc2718be7aca970defc 100644 (file)
@@ -59,7 +59,7 @@ struct dccp_tx_hist *dccp_tx_hist_new(const char *name)
        hist->dccptxh_slab = kmem_cache_create(slab_name,
                                             sizeof(struct dccp_tx_hist_entry),
                                               0, SLAB_HWCACHE_ALIGN,
-                                              NULL, NULL);
+                                              NULL);
        if (hist->dccptxh_slab == NULL)
                goto out_free_slab_name;
 out:
@@ -148,7 +148,7 @@ struct dccp_rx_hist *dccp_rx_hist_new(const char *name)
        hist->dccprxh_slab = kmem_cache_create(slab_name,
                                             sizeof(struct dccp_rx_hist_entry),
                                               0, SLAB_HWCACHE_ALIGN,
-                                              NULL, NULL);
+                                              NULL);
        if (hist->dccprxh_slab == NULL)
                goto out_free_slab_name;
 out:
index 6607b7b14f34fde9a2324f28d90a8f2555cb5fcd..04b59ec4f5121834caf429d15f84d5f0b4dde5e6 100644 (file)
@@ -1003,7 +1003,7 @@ static int __init dccp_init(void)
        dccp_hashinfo.bind_bucket_cachep =
                kmem_cache_create("dccp_bind_bucket",
                                  sizeof(struct inet_bind_bucket), 0,
-                                 SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                 SLAB_HWCACHE_ALIGN, NULL);
        if (!dccp_hashinfo.bind_bucket_cachep)
                goto out;
 
index 82622fb6f68f2acca604610421f9f654548d9d89..f2a61ef2af9cdebde1f5d217d09a8b74be9bc8c7 100644 (file)
@@ -1770,7 +1770,7 @@ void __init dn_route_init(void)
 
        dn_dst_ops.kmem_cachep =
                kmem_cache_create("dn_dst_cache", sizeof(struct dn_route), 0,
-                                 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                                 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
        init_timer(&dn_route_timer);
        dn_route_timer.function = dn_dst_check_expire;
        dn_route_timer.expires = jiffies + decnet_dst_gc_interval * HZ;
index d6615c9361e9405897dcb4609b7d500f5e4234ee..fda0772fa215afa59ab258668fecffaa95625f87 100644 (file)
@@ -881,7 +881,7 @@ void __init dn_fib_table_init(void)
        dn_hash_kmem = kmem_cache_create("dn_fib_info_cache",
                                        sizeof(struct dn_fib_info),
                                        0, SLAB_HWCACHE_ALIGN,
-                                       NULL, NULL);
+                                       NULL);
 }
 
 void __exit dn_fib_table_cleanup(void)
index 07e843a47dde6bf6c774a4080ac2ea16a688e311..9ad1d9ff9ce777232b69ad84d083fa3ba3b0b4c9 100644 (file)
@@ -771,13 +771,13 @@ struct fib_table * __init fib_hash_init(u32 id)
                fn_hash_kmem = kmem_cache_create("ip_fib_hash",
                                                 sizeof(struct fib_node),
                                                 0, SLAB_HWCACHE_ALIGN,
-                                                NULL, NULL);
+                                                NULL);
 
        if (fn_alias_kmem == NULL)
                fn_alias_kmem = kmem_cache_create("ip_fib_alias",
                                                  sizeof(struct fib_alias),
                                                  0, SLAB_HWCACHE_ALIGN,
-                                                 NULL, NULL);
+                                                 NULL);
 
        tb = kmalloc(sizeof(struct fib_table) + sizeof(struct fn_hash),
                     GFP_KERNEL);
index 30e332ade61bbb442a9660ec68e11c0871714ee5..9ca786a6fd3c8a7546b86e00dc81ae1de6fd45c0 100644 (file)
@@ -1970,7 +1970,7 @@ struct fib_table * __init fib_hash_init(u32 id)
                fn_alias_kmem = kmem_cache_create("ip_fib_alias",
                                                  sizeof(struct fib_alias),
                                                  0, SLAB_HWCACHE_ALIGN,
-                                                 NULL, NULL);
+                                                 NULL);
 
        tb = kmalloc(sizeof(struct fib_table) + sizeof(struct trie),
                     GFP_KERNEL);
index 2f44e6128068893c25343a7ad560a7b03dce252c..6cbce96a54cef2cc5722f9290181ce1b090f78a0 100644 (file)
@@ -123,7 +123,7 @@ void __init inet_initpeers(void)
        peer_cachep = kmem_cache_create("inet_peer_cache",
                        sizeof(struct inet_peer),
                        0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                       NULL, NULL);
+                       NULL);
 
        /* All the timers, started at system startup tend
           to synchronize. Perturb it a bit.
index d96582acdf69a7b4110cc4dfafc2d2c290d7a379..7003cc1b7fe26c5c87c055d15f489214f26ae356 100644 (file)
@@ -1917,7 +1917,7 @@ void __init ip_mr_init(void)
        mrt_cachep = kmem_cache_create("ip_mrt_cache",
                                       sizeof(struct mfc_cache),
                                       0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                      NULL, NULL);
+                                      NULL);
        init_timer(&ipmr_expire_timer);
        ipmr_expire_timer.function=ipmr_expire_process;
        register_netdevice_notifier(&ip_mr_notifier);
index 3b446b1a6b9c8b7b0a49642b0692d78ee2f9d212..d612a6a5d957e591c27de755d41bc2efaf6c61cd 100644 (file)
@@ -901,7 +901,7 @@ int ip_vs_conn_init(void)
        /* Allocate ip_vs_conn slab cache */
        ip_vs_conn_cachep = kmem_cache_create("ip_vs_conn",
                                              sizeof(struct ip_vs_conn), 0,
-                                             SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                             SLAB_HWCACHE_ALIGN, NULL);
        if (!ip_vs_conn_cachep) {
                vfree(ip_vs_conn_tab);
                return -ENOMEM;
index 88fa648d7ba33cf23757d1db1544c2954a230706..df42b7fb3268bb119c64f4a94b7c24d68722ec10 100644 (file)
@@ -2967,7 +2967,7 @@ int __init ip_rt_init(void)
 
        ipv4_dst_ops.kmem_cachep =
                kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
-                                 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                                 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 
        ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
 
index 987b94403be55be814fb5245300236fb0b863558..da4c0b6ab79ab5f25b5e9accddf592796c93c4ba 100644 (file)
@@ -2430,7 +2430,7 @@ void __init tcp_init(void)
        tcp_hashinfo.bind_bucket_cachep =
                kmem_cache_create("tcp_bind_bucket",
                                  sizeof(struct inet_bind_bucket), 0,
-                                 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                                 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 
        /* Size and allocate the main established and bind bucket
         * hash tables.
index 662a7d9681fdb03b4c2a9c089ec4dffdcfb2f4d2..6a612a701eaaa34b35d6d7778b80c7f62c6bde31 100644 (file)
@@ -1474,7 +1474,7 @@ void __init fib6_init(void)
        fib6_node_kmem = kmem_cache_create("fib6_nodes",
                                           sizeof(struct fib6_node),
                                           0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                          NULL, NULL);
+                                          NULL);
 
        fib6_tables_init();
 
index fe8d9837f9f89a2067b5f633d5a9cdd992385bf2..919de682b3315473ef6f09ecb129febc48af5600 100644 (file)
@@ -2555,7 +2555,7 @@ void __init ip6_route_init(void)
 #endif
        ip6_dst_ops.kmem_cachep =
                kmem_cache_create("ip6_dst_cache", sizeof(struct rt6_info), 0,
-                                 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                                 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
        ip6_dst_blackhole_ops.kmem_cachep = ip6_dst_ops.kmem_cachep;
 
        fib6_init();
index 6f87dd568dedf494bf93af3f1f4f7276ef9c3cfd..30f3236c402afd470d7a542d2121e03042a1110c 100644 (file)
@@ -84,7 +84,7 @@ static int xfrm6_tunnel_spi_init(void)
        xfrm6_tunnel_spi_kmem = kmem_cache_create("xfrm6_tunnel_spi",
                                                  sizeof(struct xfrm6_tunnel_spi),
                                                  0, SLAB_HWCACHE_ALIGN,
-                                                 NULL, NULL);
+                                                 NULL);
        if (!xfrm6_tunnel_spi_kmem)
                return -ENOMEM;
 
index 8cce814f6bee1f16d4a8d7d501b2ebff135ce0c0..aa086c83af8000e0114cb46fc76fc6c4df4af717 100644 (file)
@@ -1108,7 +1108,7 @@ int __init nf_conntrack_init(void)
 
        nf_conntrack_cachep = kmem_cache_create("nf_conntrack",
                                                sizeof(struct nf_conn),
-                                               0, 0, NULL, NULL);
+                                               0, 0, NULL);
        if (!nf_conntrack_cachep) {
                printk(KERN_ERR "Unable to create nf_conn slab cache\n");
                goto err_free_hash;
index 2191fe008f60d9800f753df273f0d510a3419dd0..1aa6229ca99f66d3e1385d9d87ec6545e315a58b 100644 (file)
@@ -540,7 +540,7 @@ int __init nf_conntrack_expect_init(void)
 
        nf_ct_expect_cachep = kmem_cache_create("nf_conntrack_expect",
                                        sizeof(struct nf_conntrack_expect),
-                                       0, 0, NULL, NULL);
+                                       0, 0, NULL);
        if (!nf_ct_expect_cachep)
                goto err2;
 
index d6b3d01975b6e5664b969e1ce81bb2f11fa2adcb..bd45f9d3f7d0b4313b3681f1f68fd584aabe3ff1 100644 (file)
@@ -738,7 +738,7 @@ static int __init xt_hashlimit_init(void)
        err = -ENOMEM;
        hashlimit_cachep = kmem_cache_create("xt_hashlimit",
                                            sizeof(struct dsthash_ent), 0, 0,
-                                           NULL, NULL);
+                                           NULL);
        if (!hashlimit_cachep) {
                printk(KERN_ERR "xt_hashlimit: unable to create slab cache\n");
                goto err2;
index 46f6d572ad2d497162c600aa35f0b74c8c8388b1..16a68df4e36b9a8ba8c4e44ceb65f39c3bfb1fe6 100644 (file)
@@ -792,7 +792,7 @@ static int __init af_rxrpc_init(void)
        ret = -ENOMEM;
        rxrpc_call_jar = kmem_cache_create(
                "rxrpc_call_jar", sizeof(struct rxrpc_call), 0,
-               SLAB_HWCACHE_ALIGN, NULL, NULL);
+               SLAB_HWCACHE_ALIGN, NULL);
        if (!rxrpc_call_jar) {
                printk(KERN_NOTICE "RxRPC: Failed to allocate call jar\n");
                goto error_call_jar;
index 34bab36637ac9a37345edf298cf485a45d1c9e32..e98579b788b858cc4dc9834dc743a3ce9b25c504 100644 (file)
@@ -980,14 +980,14 @@ SCTP_STATIC __init int sctp_init(void)
        sctp_bucket_cachep = kmem_cache_create("sctp_bind_bucket",
                                               sizeof(struct sctp_bind_bucket),
                                               0, SLAB_HWCACHE_ALIGN,
-                                              NULL, NULL);
+                                              NULL);
        if (!sctp_bucket_cachep)
                goto out;
 
        sctp_chunk_cachep = kmem_cache_create("sctp_chunk",
                                               sizeof(struct sctp_chunk),
                                               0, SLAB_HWCACHE_ALIGN,
-                                              NULL, NULL);
+                                              NULL);
        if (!sctp_chunk_cachep)
                goto err_chunk_cachep;
 
index b7111425004656a3e35be074a2372af43da29e6c..ec077037f534b6a3265342fc0ccfd1dd56893505 100644 (file)
@@ -272,8 +272,7 @@ static int init_inodecache(void)
                                              (SLAB_HWCACHE_ALIGN |
                                               SLAB_RECLAIM_ACCOUNT |
                                               SLAB_MEM_SPREAD),
-                                             init_once,
-                                             NULL);
+                                             init_once);
        if (sock_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
index 5b2b6fb244f250865c15db5bebc61f29de334f29..650af064ff8da622a612e811c48d24584b212f24 100644 (file)
@@ -867,7 +867,7 @@ int register_rpc_pipefs(void)
                                sizeof(struct rpc_inode),
                                0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
                                                SLAB_MEM_SPREAD),
-                               init_once, NULL);
+                               init_once);
        if (!rpc_inode_cachep)
                return -ENOMEM;
        err = register_filesystem(&rpc_pipe_fs_type);
index 2ac43c41c3a9889664a1c36b5072e1690ce0fea2..b5723c262a3efd4703ea95f7936994845626f956 100644 (file)
@@ -1031,13 +1031,13 @@ rpc_init_mempool(void)
        rpc_task_slabp = kmem_cache_create("rpc_tasks",
                                             sizeof(struct rpc_task),
                                             0, SLAB_HWCACHE_ALIGN,
-                                            NULL, NULL);
+                                            NULL);
        if (!rpc_task_slabp)
                goto err_nomem;
        rpc_buffer_slabp = kmem_cache_create("rpc_buffers",
                                             RPC_BUFFER_MAXSIZE,
                                             0, SLAB_HWCACHE_ALIGN,
-                                            NULL, NULL);
+                                            NULL);
        if (!rpc_buffer_slabp)
                goto err_nomem;
        rpc_task_mempool = mempool_create_slab_pool(RPC_TASK_POOLSIZE,
index e1dcf663f8a64960fdfdc824df07f071dca6818e..0c70010a7dfe9671ab9f019940354de1de5c1672 100644 (file)
@@ -97,7 +97,7 @@ int tipc_handler_start(void)
 {
        tipc_queue_item_cache =
                kmem_cache_create("tipc_queue_items", sizeof(struct queue_item),
-                                 0, SLAB_HWCACHE_ALIGN, NULL, NULL);
+                                 0, SLAB_HWCACHE_ALIGN, NULL);
        if (!tipc_queue_item_cache)
                return -ENOMEM;
 
index 5c4695840c58bde90bd0ba1ffc1abcc251dd25ad..113f44429982d26ad4ffce161187cceaf0115073 100644 (file)
@@ -83,5 +83,5 @@ void __init xfrm_input_init(void)
        secpath_cachep = kmem_cache_create("secpath_cache",
                                           sizeof(struct sec_path),
                                           0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                          NULL, NULL);
+                                          NULL);
 }
index cfaf17c8851e7ef63699cfe81af23bbde00d7041..c3a4b0a18687e83f0502697ddf59ba66a3d04593 100644 (file)
@@ -2378,7 +2378,7 @@ static void __init xfrm_policy_init(void)
        xfrm_dst_cache = kmem_cache_create("xfrm_dst_cache",
                                           sizeof(struct xfrm_dst),
                                           0, SLAB_HWCACHE_ALIGN|SLAB_PANIC,
-                                          NULL, NULL);
+                                          NULL);
 
        hmask = 8 - 1;
        sz = (hmask+1) * sizeof(struct hlist_head);
index 700400d801dcc1e5360427bfc07c9c722a256c46..01bbc6d9d19b0997a8d984cdd2373d9adc96090b 100644 (file)
@@ -1001,7 +1001,7 @@ void __init key_init(void)
 {
        /* allocate a slab in which we can store keys */
        key_jar = kmem_cache_create("key_jar", sizeof(struct key),
-                       0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL, NULL);
+                       0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
 
        /* add the special key types */
        list_add_tail(&key_type_keyring.link, &key_types_list);
index 78c408fd2b02cdf66e2e9331304da6b1bf352116..ecd06738453190dc4d2a596a7d25493ed98d170b 100644 (file)
@@ -239,7 +239,7 @@ void __init avc_init(void)
        atomic_set(&avc_cache.lru_hint, 0);
 
        avc_node_cachep = kmem_cache_create("avc_node", sizeof(struct avc_node),
-                                            0, SLAB_PANIC, NULL, NULL);
+                                            0, SLAB_PANIC, NULL);
 
        audit_log(current->audit_context, GFP_KERNEL, AUDIT_KERNEL, "AVC INITIALIZED\n");
 }
index 26356e67108ee6b683d658f5c2b2274e26069cdd..0fac6829c63a7815016f0489c83db5419b990c0a 100644 (file)
@@ -4913,7 +4913,7 @@ static __init int selinux_init(void)
 
        sel_inode_cache = kmem_cache_create("selinux_inode_security",
                                            sizeof(struct inode_security_struct),
-                                           0, SLAB_PANIC, NULL, NULL);
+                                           0, SLAB_PANIC, NULL);
        avc_init();
 
        original_ops = secondary_ops = security_ops;
index 3122908afdc1484d495faf7f4c92cc0e1cb2e31a..85705eb289e02eda07ef79170547b7d004a48e90 100644 (file)
@@ -445,7 +445,7 @@ void avtab_cache_init(void)
 {
        avtab_node_cachep = kmem_cache_create("avtab_node",
                                              sizeof(struct avtab_node),
-                                             0, SLAB_PANIC, NULL, NULL);
+                                             0, SLAB_PANIC, NULL);
 }
 
 void avtab_cache_destroy(void)