[PATCH] cpuset memory spread: slab cache filesystems

Mark file system inode and similar slab caches subject to SLAB_MEM_SPREAD
memory spreading.

If a slab cache is marked SLAB_MEM_SPREAD, then anytime that a task that's
in a cpuset with the 'memory_spread_slab' option enabled goes to allocate
from such a slab cache, the allocations are spread evenly over all the
memory nodes (task->mems_allowed) allowed to that task, instead of favoring
allocation on the node local to the current cpu.

The following inode and similar caches are marked SLAB_MEM_SPREAD:

    file                               cache
    ====                               =====
    fs/adfs/super.c                    adfs_inode_cache
    fs/affs/super.c                    affs_inode_cache
    fs/befs/linuxvfs.c                 befs_inode_cache
    fs/bfs/inode.c                     bfs_inode_cache
    fs/block_dev.c                     bdev_cache
    fs/cifs/cifsfs.c                   cifs_inode_cache
    fs/coda/inode.c                    coda_inode_cache
    fs/dquot.c                         dquot
    fs/efs/super.c                     efs_inode_cache
    fs/ext2/super.c                    ext2_inode_cache
    fs/ext2/xattr.c (fs/mbcache.c)     ext2_xattr
    fs/ext3/super.c                    ext3_inode_cache
    fs/ext3/xattr.c (fs/mbcache.c)     ext3_xattr
    fs/fat/cache.c                     fat_cache
    fs/fat/inode.c                     fat_inode_cache
    fs/freevxfs/vxfs_super.c           vxfs_inode
    fs/hpfs/super.c                    hpfs_inode_cache
    fs/isofs/inode.c                   isofs_inode_cache
    fs/jffs/inode-v23.c                jffs_fm
    fs/jffs2/super.c                   jffs2_i
    fs/jfs/super.c                     jfs_ip
    fs/minix/inode.c                   minix_inode_cache
    fs/ncpfs/inode.c                   ncp_inode_cache
    fs/nfs/direct.c                    nfs_direct_cache
    fs/nfs/inode.c                     nfs_inode_cache
    fs/ntfs/super.c                    ntfs_big_inode_cache_name
    fs/ntfs/super.c                    ntfs_inode_cache
    fs/ocfs2/dlm/dlmfs.c               dlmfs_inode_cache
    fs/ocfs2/super.c                   ocfs2_inode_cache
    fs/proc/inode.c                    proc_inode_cache
    fs/qnx4/inode.c                    qnx4_inode_cache
    fs/reiserfs/super.c                reiser_inode_cache
    fs/romfs/inode.c                   romfs_inode_cache
    fs/smbfs/inode.c                   smb_inode_cache
    fs/sysv/inode.c                    sysv_inode_cache
    fs/udf/super.c                     udf_inode_cache
    fs/ufs/super.c                     ufs_inode_cache
    net/socket.c                       sock_inode_cache
    net/sunrpc/rpc_pipe.c              rpc_inode_cache

The choice of which slab caches to so mark was quite simple.  I marked
those already marked SLAB_RECLAIM_ACCOUNT, except for fs/xfs, dentry_cache,
inode_cache, and buffer_head, which were marked in a previous patch.  Even
though SLAB_RECLAIM_ACCOUNT is for a different purpose, it marks the same
potentially large file system i/o related slab caches as we need for memory
spreading.

Given that the rule now becomes "wherever you would have used a
SLAB_RECLAIM_ACCOUNT slab cache flag before (usually the inode cache), use
the SLAB_MEM_SPREAD flag too", this should be easy enough to maintain.
Future file system writers will just copy one of the existing file system
slab cache setups and tend to get it right without thinking.

Signed-off-by: Paul Jackson <pj@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/fs/adfs/super.c b/fs/adfs/super.c
index 243963228d10e98572fa8d7de34effc412bc0129..80f798b7d7602f2adf051a8bca7c7095396cac3a 100644 (file)
--- a/fs/adfs/super.c
+++ b/fs/adfs/super.c
@@ -241,7 +241,7 @@ static int init_inodecache(void)
 {
        adfs_inode_cachep = kmem_cache_create("adfs_inode_cache",
                                             sizeof(struct adfs_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (adfs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/affs/super.c b/fs/affs/super.c
index aaec015a16e4f48d5ee3c124006ac47f91e4ec33..216536d77a5f2f1f4b8e95619da5e34596261933 100644 (file)
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -98,7 +98,7 @@ static int init_inodecache(void)
 {
        affs_inode_cachep = kmem_cache_create("affs_inode_cache",
                                             sizeof(struct affs_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (affs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index dd6048ce053293ec54cd6ae127f92b74cd113781..ac031686d6d71b79fe9e6d5795bb6057089c7162 100644 (file)
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -427,7 +427,7 @@ befs_init_inodecache(void)
 {
        befs_inode_cachep = kmem_cache_create("befs_inode_cache",
                                              sizeof (struct befs_inode_info),
-                                             0, SLAB_RECLAIM_ACCOUNT,
+                                             0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                              init_once, NULL);
        if (befs_inode_cachep == NULL) {
                printk(KERN_ERR "befs_init_inodecache: "

diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c
index 3af6c73c5b5a69fe3831e6e8d6b588715f0dfb69..584a0838ac610ec4787439629550d21b54e5d91c 100644 (file)
--- a/fs/bfs/inode.c
+++ b/fs/bfs/inode.c
@@ -257,7 +257,7 @@ static int init_inodecache(void)
 {
        bfs_inode_cachep = kmem_cache_create("bfs_inode_cache",
                                             sizeof(struct bfs_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (bfs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/block_dev.c b/fs/block_dev.c
index 44d05e6e34dbc941ead6bc23202fae7cc5a04ff2..80f97729e57f350018b95e8dad3d2bdb7ad699c1 100644 (file)
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -319,7 +319,7 @@ void __init bdev_cache_init(void)
 {
        int err;
        bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode),
-                       0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_PANIC,
+                       0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|SLAB_PANIC,
                        init_once, NULL);
        err = register_filesystem(&bd_type);
        if (err)

diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 1cd044ce82a625ee77eeb88de0f46c4db6ec0ba2..ba5a24b99a11212bb055beef34e52878653f3aa7 100644 (file)
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -695,7 +695,7 @@ cifs_init_inodecache(void)
 {
        cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
                                              sizeof (struct cifsInodeInfo),
-                                             0, SLAB_RECLAIM_ACCOUNT,
+                                             0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                              cifs_init_once, NULL);
        if (cifs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index 7d7d52f74b28db2a79d5578e19e971d994d6072a..ada1a81df6bdb807af15b429823f54b89a634434 100644 (file)
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -71,7 +71,7 @@ int coda_init_inodecache(void)
 {
        coda_inode_cachep = kmem_cache_create("coda_inode_cache",
                                sizeof(struct coda_inode_info),
-                               0, SLAB_RECLAIM_ACCOUNT,
+                               0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                init_once, NULL);
        if (coda_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/dquot.c b/fs/dquot.c
index acf07e581f8cc5577e824711a1e9447992db48ec..1405755b8e4d4d2a73c483f35bf6f5f714e5045c 100644 (file)
--- a/fs/dquot.c
+++ b/fs/dquot.c
@@ -1821,7 +1821,7 @@ static int __init dquot_init(void)
 
        dquot_cachep = kmem_cache_create("dquot", 
                        sizeof(struct dquot), sizeof(unsigned long) * 4,
-                       SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_PANIC,
+                       SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|SLAB_PANIC,
                        NULL, NULL);
 
        order = 0;

diff --git a/fs/efs/super.c b/fs/efs/super.c
index afc4891feb36b7649a8a5c9f731a98c7d23f28f1..dff623e3ddbfec7ccca9ec87bfc3410041278e5b 100644 (file)
--- a/fs/efs/super.c
+++ b/fs/efs/super.c
@@ -81,7 +81,7 @@ static int init_inodecache(void)
 {
        efs_inode_cachep = kmem_cache_create("efs_inode_cache",
                                sizeof(struct efs_inode_info),
-                               0, SLAB_RECLAIM_ACCOUNT,
+                               0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                init_once, NULL);
        if (efs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 7f3899bdebabdaa4b7a358f5dce6ce48f9879e68..e153f0cc240bbcaf3fa46b6c3935ef4ddba55187 100644 (file)
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -175,7 +175,7 @@ static int init_inodecache(void)
 {
        ext2_inode_cachep = kmem_cache_create("ext2_inode_cache",
                                             sizeof(struct ext2_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (ext2_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index efe5b20d7a5aedc493e7c10d7adc61a610b1c808..e4a0a7cbb5b22896b0a979b9224361bc41a65f9e 100644 (file)
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -481,7 +481,7 @@ static int init_inodecache(void)
 {
        ext3_inode_cachep = kmem_cache_create("ext3_inode_cache",
                                             sizeof(struct ext3_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (ext3_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/fat/cache.c b/fs/fat/cache.c
index 1acc941245fb4a4c751c972684202b19d0f2208a..97b967b84fc6070b7efc47887345a8e574f5d147 100644 (file)
--- a/fs/fat/cache.c
+++ b/fs/fat/cache.c
@@ -49,7 +49,7 @@ int __init fat_cache_init(void)
 {
        fat_cache_cachep = kmem_cache_create("fat_cache",
                                sizeof(struct fat_cache),
-                               0, SLAB_RECLAIM_ACCOUNT,
+                               0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                init_once, NULL);
        if (fat_cache_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index e78d7b4842cc49f60689094051373a6b4a3969b6..a75708901e73b54181cf79426cbab364389ebdae 100644 (file)
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -518,7 +518,7 @@ static int __init fat_init_inodecache(void)
 {
        fat_inode_cachep = kmem_cache_create("fat_inode_cache",
                                             sizeof(struct msdos_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (fat_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/freevxfs/vxfs_super.c b/fs/freevxfs/vxfs_super.c
index 6aa6fbe4f8ee9a5397408d59938140e38fa4c084..b44c916d24a187f84e78db662c564dd98b818a09 100644 (file)
--- a/fs/freevxfs/vxfs_super.c
+++ b/fs/freevxfs/vxfs_super.c
@@ -260,7 +260,7 @@ vxfs_init(void)
 {
        vxfs_inode_cachep = kmem_cache_create("vxfs_inode",
                        sizeof(struct vxfs_inode_info), 0, 
-                       SLAB_RECLAIM_ACCOUNT, NULL, NULL);
+                       SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL, NULL);
        if (vxfs_inode_cachep)
                return register_filesystem(&vxfs_fs_type);
        return -ENOMEM;

diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index 9488a794076e08539f535f5a2cd096990c58ed3a..25fbefe4ed004655d03992e7720da70e5d4b1ad1 100644 (file)
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -191,7 +191,7 @@ static int init_inodecache(void)
 {
        hpfs_inode_cachep = kmem_cache_create("hpfs_inode_cache",
                                             sizeof(struct hpfs_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (hpfs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 298f08be22d46ceb2e8a0d11121d9e3de7ecd594..fcb68151ad866d49f9c4258c4b5447c591752805 100644 (file)
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -87,7 +87,7 @@ static int init_inodecache(void)
 {
        isofs_inode_cachep = kmem_cache_create("isofs_inode_cache",
                                             sizeof(struct iso_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (isofs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/jffs/inode-v23.c b/fs/jffs/inode-v23.c
index 890d7ff7456d090a73bdddf77b00858406179d8f..ffa49861d9855b6b4ba082fc81b93021282cec9c 100644 (file)
--- a/fs/jffs/inode-v23.c
+++ b/fs/jffs/inode-v23.c
@@ -1812,14 +1812,14 @@ init_jffs_fs(void)
        }
 #endif
        fm_cache = kmem_cache_create("jffs_fm", sizeof(struct jffs_fm),
-                                    0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT, 
+                                    0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                     NULL, NULL);
        if (!fm_cache) {
                return -ENOMEM;
        }
 
        node_cache = kmem_cache_create("jffs_node",sizeof(struct jffs_node),
-                                      0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT, 
+                                      0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                       NULL, NULL);
        if (!node_cache) {
                kmem_cache_destroy(fm_cache);

diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index c8fac352a4cf3ae2ff13828d6256d1762e82d571..f2563389581c9a6086e7a4ec5bf33cf6882e9369 100644 (file)
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -331,7 +331,7 @@ static int __init init_jffs2_fs(void)
 
        jffs2_inode_cachep = kmem_cache_create("jffs2_i",
                                             sizeof(struct jffs2_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             jffs2_i_init_once, NULL);
        if (!jffs2_inode_cachep) {
                printk(KERN_ERR "JFFS2 error: Failed to initialise inode cache\n");

diff --git a/fs/jfs/super.c b/fs/jfs/super.c
index 18f69e6aa719358e793c31745cd1831b4eded107..4ac40bfdbd84306206c0430a6d471070e142a2c4 100644 (file)
--- a/fs/jfs/super.c
+++ b/fs/jfs/super.c
@@ -664,7 +664,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, init_once, NULL);
+                           SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, init_once, NULL);
        if (jfs_inode_cachep == NULL)
                return -ENOMEM;
 

diff --git a/fs/mbcache.c b/fs/mbcache.c
index f5bbe4c97c5800b1ea0b2c342c0352747deed074..73e754fea2d8639ebc99331fe68f5e24cde00f19 100644 (file)
--- a/fs/mbcache.c
+++ b/fs/mbcache.c
@@ -288,7 +288,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, NULL, NULL);
+               SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL, NULL);
        if (!cache->c_entry_cache)
                goto fail;
 

diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index 790cc0d0e970a643b7387ea964eb1e8d7fde0fcc..4fabef0b6519c9021815ce3b348810e8c74dda57 100644 (file)
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -80,7 +80,7 @@ static int init_inodecache(void)
 {
        minix_inode_cachep = kmem_cache_create("minix_inode_cache",
                                             sizeof(struct minix_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (minix_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/ncpfs/inode.c b/fs/ncpfs/inode.c
index 0b521d3d97ce6ec0c24bcafae03592e5dd44cf59..2547ebaa6547417520270addb218fbab7e554e88 100644 (file)
--- a/fs/ncpfs/inode.c
+++ b/fs/ncpfs/inode.c
@@ -72,7 +72,7 @@ static int init_inodecache(void)
 {
        ncp_inode_cachep = kmem_cache_create("ncp_inode_cache",
                                             sizeof(struct ncp_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (ncp_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 4e9b3a1b36c5cc1f38b7246f94933765b2376775..751f5b5e7e07e473791ab4617e1a3f82d5248435 100644 (file)
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -781,7 +781,7 @@ int nfs_init_directcache(void)
 {
        nfs_direct_cachep = kmem_cache_create("nfs_direct_cache",
                                                sizeof(struct nfs_direct_req),
-                                               0, SLAB_RECLAIM_ACCOUNT,
+                                               0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                                NULL, NULL);
        if (nfs_direct_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 419d1d254f9fe6e15cd3dd3ea1182c83c31c306c..834c1e905ce16ec3fed0d98d0c07a35e4a7d5b91 100644 (file)
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -2163,7 +2163,7 @@ static int nfs_init_inodecache(void)
 {
        nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
                                             sizeof(struct nfs_inode),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (nfs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index 7646b5059389273db88d564b5b3bb01dc3e750d4..27833f6df49f561e50f304c1b92549043cdeac23 100644 (file)
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -3163,7 +3163,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, NULL, NULL);
+                       SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL, NULL);
        if (!ntfs_inode_cache) {
                printk(KERN_CRIT "NTFS: Failed to create %s!\n",
                                ntfs_inode_cache_name);
@@ -3172,7 +3172,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_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                        ntfs_big_inode_init_once, NULL);
        if (!ntfs_big_inode_cache) {
                printk(KERN_CRIT "NTFS: Failed to create %s!\n",

diff --git a/fs/ocfs2/dlm/dlmfs.c b/fs/ocfs2/dlm/dlmfs.c
index dd2d24dc25e0448239ad114375bc37e68ee92696..ca8587cc58bcf59ef850514eb69c2e88092f1e35 100644 (file)
--- a/fs/ocfs2/dlm/dlmfs.c
+++ b/fs/ocfs2/dlm/dlmfs.c
@@ -596,7 +596,7 @@ static int __init init_dlmfs_fs(void)
 
        dlmfs_inode_cache = kmem_cache_create("dlmfs_inode_cache",
                                sizeof(struct dlmfs_inode_private),
-                               0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
+                               0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                dlmfs_init_once, NULL);
        if (!dlmfs_inode_cache)
                return -ENOMEM;

diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 09e1c57a86a08d7bd22883058ab439b923593e03..3fe7896c666a4c9db20cb1fa42b65430af0cd713 100644 (file)
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -951,7 +951,7 @@ static int ocfs2_initialize_mem_caches(void)
 {
        ocfs2_inode_cachep = kmem_cache_create("ocfs2_inode_cache",
                                               sizeof(struct ocfs2_inode_info),
-                                              0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
+                                              0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                               ocfs2_inode_init_once, NULL);
        if (!ocfs2_inode_cachep)
                return -ENOMEM;

diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 075d3e945602c92ab22122944727311301ff2491..5ac781801ae7efaf005d635ee26a55e50177ea75 100644 (file)
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -121,7 +121,7 @@ int __init proc_init_inodecache(void)
 {
        proc_inode_cachep = kmem_cache_create("proc_inode_cache",
                                             sizeof(struct proc_inode),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (proc_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c
index 80f32911c0cb4bea686459920215191377287e01..463142c80ae87f5a9419a659bc1e402669774c1a 100644 (file)
--- a/fs/qnx4/inode.c
+++ b/fs/qnx4/inode.c
@@ -546,7 +546,7 @@ static int init_inodecache(void)
 {
        qnx4_inode_cachep = kmem_cache_create("qnx4_inode_cache",
                                             sizeof(struct qnx4_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (qnx4_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index d63da756eb49b0096480b58adb519dc01bb2fdf5..bf4346057879add52a832bdfea0176ddc0d88d73 100644 (file)
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -521,7 +521,7 @@ static int init_inodecache(void)
        reiserfs_inode_cachep = kmem_cache_create("reiser_inode_cache",
                                                  sizeof(struct
                                                         reiserfs_inode_info),
-                                                 0, SLAB_RECLAIM_ACCOUNT,
+                                                 0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                                  init_once, NULL);
        if (reiserfs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/romfs/inode.c b/fs/romfs/inode.c
index 0a13859fd57bc0cb8d5302e2fc933bd3a943f88d..223bebb8b45e35db66d196190915096c9272a2a4 100644 (file)
--- a/fs/romfs/inode.c
+++ b/fs/romfs/inode.c
@@ -579,7 +579,7 @@ static int init_inodecache(void)
 {
        romfs_inode_cachep = kmem_cache_create("romfs_inode_cache",
                                             sizeof(struct romfs_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (romfs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/smbfs/inode.c b/fs/smbfs/inode.c
index 02e3e82d465c5ff28f906f0c3fcd081a5654e66c..9b14542cc186dcb6e40f9e913f22ae9cd6225d68 100644 (file)
--- a/fs/smbfs/inode.c
+++ b/fs/smbfs/inode.c
@@ -80,7 +80,7 @@ static int init_inodecache(void)
 {
        smb_inode_cachep = kmem_cache_create("smb_inode_cache",
                                             sizeof(struct smb_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (smb_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/sysv/inode.c b/fs/sysv/inode.c
index fa33eceb00113d05bb826a15300c9971e45cb348..3ff89cc5833a4ea88156204541375cce9307b6aa 100644 (file)
--- a/fs/sysv/inode.c
+++ b/fs/sysv/inode.c
@@ -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_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                        init_once, NULL);
        if (!sysv_inode_cachep)
                return -ENOMEM;

diff --git a/fs/udf/super.c b/fs/udf/super.c
index 0d555616c9396c10d3c52a3d17f5a450887a06b0..e120f33f84734932057612f4b4bc73f642318866 100644 (file)
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -140,7 +140,7 @@ static int init_inodecache(void)
 {
        udf_inode_cachep = kmem_cache_create("udf_inode_cache",
                                             sizeof(struct udf_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (udf_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index e9055ef7f5ac97dbe33791e0d5f9c227a06985f9..684018d3c58e344e26d2f2402062aa3d689e09a2 100644 (file)
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -1184,7 +1184,7 @@ static int init_inodecache(void)
 {
        ufs_inode_cachep = kmem_cache_create("ufs_inode_cache",
                                             sizeof(struct ufs_inode_info),
-                                            0, SLAB_RECLAIM_ACCOUNT,
+                                            0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                             init_once, NULL);
        if (ufs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/net/socket.c b/net/socket.c
index e2d5bae994de2f4bcd65f93550aadcbf601ee9d3..7a5a56874efa34e311abcc354ffa24ccdaad71b7 100644 (file)
--- a/net/socket.c
+++ b/net/socket.c
@@ -319,7 +319,7 @@ static int init_inodecache(void)
 {
        sock_inode_cachep = kmem_cache_create("sock_inode_cache",
                                sizeof(struct socket_alloc),
-                               0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
+                               0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                init_once, NULL);
        if (sock_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index a5c0c7b6e151b4a8712ec67d3c3cdbf32308497c..befc0c5ca9e5682e0bb97ecb9da783a479391b4c 100644 (file)
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -850,7 +850,7 @@ int register_rpc_pipefs(void)
 {
        rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
                                              sizeof(struct rpc_inode),
-                                             0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
+                                             0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
                                              init_once, NULL);
        if (!rpc_inode_cachep)
                return -ENOMEM;