mm, slab: remove last vestiges of SLAB_MEM_SPREAD

Yes, yes, I know the slab people were planning on going slow and letting
every subsystem fight this thing on their own.  But let's just rip off
the band-aid and get it over and done with.  I don't want to see a
number of unnecessary pull requests just to get rid of a flag that no
longer has any meaning.

This was mainly done with a couple of 'sed' scripts and then some manual
cleanup of the end result.

Link: https://lore.kernel.org/all/CAHk-=wji0u+OOtmAOD-5JV3SXcRJF___k_+8XNKmak0yd5vW1Q@mail.gmail.com/
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/drivers/dax/super.c b/drivers/dax/super.c
index f4b6355..a0244f6 100644 (file)
--- a/drivers/dax/super.c
+++ b/drivers/dax/super.c
@@ -532,8 +532,7 @@ static int dax_fs_init(void)
        int rc;
 
        dax_cache = kmem_cache_create("dax_cache", sizeof(struct dax_device), 0,
-                       (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
-                        SLAB_MEM_SPREAD|SLAB_ACCOUNT),
+                       SLAB_HWCACHE_ALIGN | SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
                        init_once);
        if (!dax_cache)
                return -ENOMEM;

diff --git a/drivers/usb/isp1760/isp1760-hcd.c b/drivers/usb/isp1760/isp1760-hcd.c
index 76862ba..0e5e4cb 100644 (file)
--- a/drivers/usb/isp1760/isp1760-hcd.c
+++ b/drivers/usb/isp1760/isp1760-hcd.c
@@ -2521,21 +2521,19 @@ static const struct hc_driver isp1760_hc_driver = {
 int __init isp1760_init_kmem_once(void)
 {
        urb_listitem_cachep = kmem_cache_create("isp1760_urb_listitem",
-                       sizeof(struct urb_listitem), 0, SLAB_TEMPORARY |
-                       SLAB_MEM_SPREAD, NULL);
+                       sizeof(struct urb_listitem), 0, SLAB_TEMPORARY, NULL);
 
        if (!urb_listitem_cachep)
                return -ENOMEM;
 
        qtd_cachep = kmem_cache_create("isp1760_qtd",
-                       sizeof(struct isp1760_qtd), 0, SLAB_TEMPORARY |
-                       SLAB_MEM_SPREAD, NULL);
+                       sizeof(struct isp1760_qtd), 0, SLAB_TEMPORARY, NULL);
 
        if (!qtd_cachep)
                goto destroy_urb_listitem;
 
        qh_cachep = kmem_cache_create("isp1760_qh", sizeof(struct isp1760_qh),
-                       0, SLAB_TEMPORARY | SLAB_MEM_SPREAD, NULL);
+                       0, SLAB_TEMPORARY, NULL);
 
        if (!qh_cachep)
                goto destroy_qtd;

diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c
index 61dbe52..281a1ed 100644 (file)
--- a/fs/9p/v9fs.c
+++ b/fs/9p/v9fs.c
@@ -637,7 +637,7 @@ static int v9fs_init_inode_cache(void)
        v9fs_inode_cache = kmem_cache_create("v9fs_inode_cache",
                                          sizeof(struct v9fs_inode),
                                          0, (SLAB_RECLAIM_ACCOUNT|
-                                             SLAB_MEM_SPREAD|SLAB_ACCOUNT),
+                                             SLAB_ACCOUNT),
                                          v9fs_inode_init_once);
        if (!v9fs_inode_cache)
                return -ENOMEM;

diff --git a/fs/adfs/super.c b/fs/adfs/super.c
index e8bfc38..9354b14 100644 (file)
--- a/fs/adfs/super.c
+++ b/fs/adfs/super.c
@@ -249,7 +249,7 @@ static int __init init_inodecache(void)
        adfs_inode_cachep = kmem_cache_create("adfs_inode_cache",
                                             sizeof(struct adfs_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
-                                               SLAB_MEM_SPREAD|SLAB_ACCOUNT),
+                                               SLAB_ACCOUNT),
                                             init_once);
        if (adfs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 2b4dda0..d76f406 100644 (file)
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -435,8 +435,7 @@ befs_init_inodecache(void)
 {
        befs_inode_cachep = kmem_cache_create_usercopy("befs_inode_cache",
                                sizeof(struct befs_inode_info), 0,
-                               (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
-                                       SLAB_ACCOUNT),
+                               SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
                                offsetof(struct befs_inode_info,
                                        i_data.symlink),
                                sizeof_field(struct befs_inode_info,

diff --git a/fs/bfs/inode.c b/fs/bfs/inode.c
index 355957d..db81570 100644 (file)
--- a/fs/bfs/inode.c
+++ b/fs/bfs/inode.c
@@ -259,7 +259,7 @@ static int __init init_inodecache(void)
        bfs_inode_cachep = kmem_cache_create("bfs_inode_cache",
                                             sizeof(struct bfs_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT|
-                                               SLAB_MEM_SPREAD|SLAB_ACCOUNT),
+                                               SLAB_ACCOUNT),
                                             init_once);
        if (bfs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/ceph/super.c b/fs/ceph/super.c
index 5ec102f..885cb5d 100644 (file)
--- a/fs/ceph/super.c
+++ b/fs/ceph/super.c
@@ -928,36 +928,36 @@ static int __init init_caches(void)
        ceph_inode_cachep = kmem_cache_create("ceph_inode_info",
                                      sizeof(struct ceph_inode_info),
                                      __alignof__(struct ceph_inode_info),
-                                     SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
-                                     SLAB_ACCOUNT, ceph_inode_init_once);
+                                     SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
+                                     ceph_inode_init_once);
        if (!ceph_inode_cachep)
                return -ENOMEM;
 
-       ceph_cap_cachep = KMEM_CACHE(ceph_cap, SLAB_MEM_SPREAD);
+       ceph_cap_cachep = KMEM_CACHE(ceph_cap, 0);
        if (!ceph_cap_cachep)
                goto bad_cap;
-       ceph_cap_snap_cachep = KMEM_CACHE(ceph_cap_snap, SLAB_MEM_SPREAD);
+       ceph_cap_snap_cachep = KMEM_CACHE(ceph_cap_snap, 0);
        if (!ceph_cap_snap_cachep)
                goto bad_cap_snap;
        ceph_cap_flush_cachep = KMEM_CACHE(ceph_cap_flush,
-                                          SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD);
+                                          SLAB_RECLAIM_ACCOUNT);
        if (!ceph_cap_flush_cachep)
                goto bad_cap_flush;
 
        ceph_dentry_cachep = KMEM_CACHE(ceph_dentry_info,
-                                       SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD);
+                                       SLAB_RECLAIM_ACCOUNT);
        if (!ceph_dentry_cachep)
                goto bad_dentry;
 
-       ceph_file_cachep = KMEM_CACHE(ceph_file_info, SLAB_MEM_SPREAD);
+       ceph_file_cachep = KMEM_CACHE(ceph_file_info, 0);
        if (!ceph_file_cachep)
                goto bad_file;
 
-       ceph_dir_file_cachep = KMEM_CACHE(ceph_dir_file_info, SLAB_MEM_SPREAD);
+       ceph_dir_file_cachep = KMEM_CACHE(ceph_dir_file_info, 0);
        if (!ceph_dir_file_cachep)
                goto bad_dir_file;
 
-       ceph_mds_request_cachep = KMEM_CACHE(ceph_mds_request, SLAB_MEM_SPREAD);
+       ceph_mds_request_cachep = KMEM_CACHE(ceph_mds_request, 0);
        if (!ceph_mds_request_cachep)
                goto bad_mds_req;
 

diff --git a/fs/coda/inode.c b/fs/coda/inode.c
index a50356c..6898dc6 100644 (file)
--- a/fs/coda/inode.c
+++ b/fs/coda/inode.c
@@ -72,8 +72,8 @@ int __init 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|
-                               SLAB_ACCOUNT, init_once);
+                               SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
+                               init_once);
        if (coda_inode_cachep == NULL)
                return -ENOMEM;
        return 0;

diff --git a/fs/erofs/super.c b/fs/erofs/super.c
index 6fbb1fb..69308fd 100644 (file)
--- a/fs/erofs/super.c
+++ b/fs/erofs/super.c
@@ -857,7 +857,7 @@ static int __init erofs_module_init(void)
 
        erofs_inode_cachep = kmem_cache_create("erofs_inode",
                        sizeof(struct erofs_inode), 0,
-                       SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | SLAB_ACCOUNT,
+                       SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
                        erofs_inode_init_once);
        if (!erofs_inode_cachep)
                return -ENOMEM;

diff --git a/fs/exfat/cache.c b/fs/exfat/cache.c
index 5a2f119..7cc200d 100644 (file)
--- a/fs/exfat/cache.c
+++ b/fs/exfat/cache.c
@@ -46,7 +46,7 @@ int exfat_cache_init(void)
 {
        exfat_cachep = kmem_cache_create("exfat_cache",
                                sizeof(struct exfat_cache),
-                               0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
+                               0, SLAB_RECLAIM_ACCOUNT,
                                exfat_cache_init_once);
        if (!exfat_cachep)
                return -ENOMEM;

diff --git a/fs/exfat/super.c b/fs/exfat/super.c
index fcb6582..3d5ea2c 100644 (file)
--- a/fs/exfat/super.c
+++ b/fs/exfat/super.c
@@ -813,7 +813,7 @@ static int __init init_exfat_fs(void)
 
        exfat_inode_cachep = kmem_cache_create("exfat_inode_cache",
                        sizeof(struct exfat_inode_info),
-                       0, SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
+                       0, SLAB_RECLAIM_ACCOUNT,
                        exfat_inode_init_once);
        if (!exfat_inode_cachep) {
                err = -ENOMEM;

diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 01f9add..cabea88 100644 (file)
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -213,8 +213,7 @@ static int __init init_inodecache(void)
 {
        ext2_inode_cachep = kmem_cache_create_usercopy("ext2_inode_cache",
                                sizeof(struct ext2_inode_info), 0,
-                               (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
-                                       SLAB_ACCOUNT),
+                               SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
                                offsetof(struct ext2_inode_info, i_data),
                                sizeof_field(struct ext2_inode_info, i_data),
                                init_once);

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index a8ba84e..59c72b6 100644 (file)
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -1500,8 +1500,7 @@ static int __init init_inodecache(void)
 {
        ext4_inode_cachep = kmem_cache_create_usercopy("ext4_inode_cache",
                                sizeof(struct ext4_inode_info), 0,
-                               (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
-                                       SLAB_ACCOUNT),
+                               SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
                                offsetof(struct ext4_inode_info, i_data),
                                sizeof_field(struct ext4_inode_info, i_data),
                                init_once);

diff --git a/fs/fat/cache.c b/fs/fat/cache.c
index 738e427..2af424e 100644 (file)
--- a/fs/fat/cache.c
+++ b/fs/fat/cache.c
@@ -47,7 +47,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,
+                               0, SLAB_RECLAIM_ACCOUNT,
                                init_once);
        if (fat_cache_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 5c81369..d9e6fbb 100644 (file)
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -787,7 +787,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|
-                                               SLAB_MEM_SPREAD|SLAB_ACCOUNT),
+                                               SLAB_ACCOUNT),
                                             init_once);
        if (fat_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/freevxfs/vxfs_super.c b/fs/freevxfs/vxfs_super.c
index e6e2a21..42e03b6 100644 (file)
--- a/fs/freevxfs/vxfs_super.c
+++ b/fs/freevxfs/vxfs_super.c
@@ -307,7 +307,7 @@ vxfs_init(void)
 
        vxfs_inode_cachep = kmem_cache_create_usercopy("vxfs_inode",
                        sizeof(struct vxfs_inode_info), 0,
-                       SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
+                       SLAB_RECLAIM_ACCOUNT,
                        offsetof(struct vxfs_inode_info, vii_immed.vi_immed),
                        sizeof_field(struct vxfs_inode_info,
                                vii_immed.vi_immed),

diff --git a/fs/gfs2/main.c b/fs/gfs2/main.c
index 79be0cd..04cadc0 100644 (file)
--- a/fs/gfs2/main.c
+++ b/fs/gfs2/main.c
@@ -111,7 +111,6 @@ static int __init init_gfs2_fs(void)
        gfs2_inode_cachep = kmem_cache_create("gfs2_inode",
                                              sizeof(struct gfs2_inode),
                                              0,  SLAB_RECLAIM_ACCOUNT|
-                                                 SLAB_MEM_SPREAD|
                                                  SLAB_ACCOUNT,
                                              gfs2_init_inode_once);
        if (!gfs2_inode_cachep)

diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index 6b0ba3c..314834a 100644 (file)
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -255,7 +255,7 @@ 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|SLAB_ACCOUNT),
+                                               SLAB_ACCOUNT),
                                             init_once);
        if (hpfs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 3e4d53e..25fca44 100644 (file)
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -93,7 +93,7 @@ static int __init init_inodecache(void)
        isofs_inode_cachep = kmem_cache_create("isofs_inode_cache",
                                        sizeof(struct iso_inode_info),
                                        0, (SLAB_RECLAIM_ACCOUNT|
-                                       SLAB_MEM_SPREAD|SLAB_ACCOUNT),
+                                       SLAB_ACCOUNT),
                                        init_once);
        if (!isofs_inode_cachep)
                return -ENOMEM;

diff --git a/fs/jffs2/super.c b/fs/jffs2/super.c
index f99591a..aede1be 100644 (file)
--- a/fs/jffs2/super.c
+++ b/fs/jffs2/super.c
@@ -387,7 +387,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|
-                                               SLAB_MEM_SPREAD|SLAB_ACCOUNT),
+                                               SLAB_ACCOUNT),
                                             jffs2_i_init_once);
        if (!jffs2_inode_cachep) {
                pr_err("error: Failed to initialise inode cache\n");

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

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index ebb8d60..93ea49a 100644 (file)
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -2372,7 +2372,7 @@ 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|SLAB_ACCOUNT),
+                                               SLAB_ACCOUNT),
                                             init_once);
        if (nfs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/nfs/nfs42xattr.c b/fs/nfs/nfs42xattr.c
index 49aaf28..b6e3d8f 100644 (file)
--- a/fs/nfs/nfs42xattr.c
+++ b/fs/nfs/nfs42xattr.c
@@ -1017,7 +1017,7 @@ int __init nfs4_xattr_cache_init(void)
 
        nfs4_xattr_cache_cachep = kmem_cache_create("nfs4_xattr_cache_cache",
            sizeof(struct nfs4_xattr_cache), 0,
-           (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD),
+           (SLAB_RECLAIM_ACCOUNT),
            nfs4_xattr_cache_init_once);
        if (nfs4_xattr_cache_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/ntfs3/super.c b/fs/ntfs3/super.c
index cef5467..9df7c20 100644 (file)
--- a/fs/ntfs3/super.c
+++ b/fs/ntfs3/super.c
@@ -1825,7 +1825,7 @@ static int __init init_ntfs_fs(void)
 
        ntfs_inode_cachep = kmem_cache_create(
                "ntfs_inode_cache", sizeof(struct ntfs_inode), 0,
-               (SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | SLAB_ACCOUNT),
+               (SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT),
                init_once);
        if (!ntfs_inode_cachep) {
                err = -ENOMEM;

diff --git a/fs/ocfs2/dlmfs/dlmfs.c b/fs/ocfs2/dlmfs/dlmfs.c
index 8521516..7fc0e92 100644 (file)
--- a/fs/ocfs2/dlmfs/dlmfs.c
+++ b/fs/ocfs2/dlmfs/dlmfs.c
@@ -578,7 +578,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|
-                                       SLAB_MEM_SPREAD|SLAB_ACCOUNT),
+                                       SLAB_ACCOUNT),
                                dlmfs_init_once);
        if (!dlmfs_inode_cache) {
                status = -ENOMEM;

diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index a70aff1..b3f8608 100644 (file)
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -1706,18 +1706,17 @@ static int ocfs2_initialize_mem_caches(void)
                                       sizeof(struct ocfs2_inode_info),
                                       0,
                                       (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
-                                               SLAB_MEM_SPREAD|SLAB_ACCOUNT),
+                                               SLAB_ACCOUNT),
                                       ocfs2_inode_init_once);
        ocfs2_dquot_cachep = kmem_cache_create("ocfs2_dquot_cache",
                                        sizeof(struct ocfs2_dquot),
                                        0,
-                                       (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
-                                               SLAB_MEM_SPREAD),
+                                       (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT),
                                        NULL);
        ocfs2_qf_chunk_cachep = kmem_cache_create("ocfs2_qf_chunk_cache",
                                        sizeof(struct ocfs2_quota_chunk),
                                        0,
-                                       (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD),
+                                       (SLAB_RECLAIM_ACCOUNT),
                                        NULL);
        if (!ocfs2_inode_cachep || !ocfs2_dquot_cachep ||
            !ocfs2_qf_chunk_cachep) {

diff --git a/fs/overlayfs/super.c b/fs/overlayfs/super.c
index 36d4b8b..a40fc7e 100644 (file)
--- a/fs/overlayfs/super.c
+++ b/fs/overlayfs/super.c
@@ -1503,7 +1503,7 @@ static int __init ovl_init(void)
        ovl_inode_cachep = kmem_cache_create("ovl_inode",
                                             sizeof(struct ovl_inode), 0,
                                             (SLAB_RECLAIM_ACCOUNT|
-                                             SLAB_MEM_SPREAD|SLAB_ACCOUNT),
+                                             SLAB_ACCOUNT),
                                             ovl_inode_init_once);
        if (ovl_inode_cachep == NULL)
                return -ENOMEM;

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

diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
index 1f0c754..eb6e9d9 100644 (file)
--- a/fs/quota/dquot.c
+++ b/fs/quota/dquot.c
@@ -2984,7 +2984,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_MEM_SPREAD|SLAB_PANIC),
+                               SLAB_PANIC),
                        NULL);
 
        order = 0;

diff --git a/fs/smb/client/cifsfs.c b/fs/smb/client/cifsfs.c
index fb368b1..e0d8c79 100644 (file)
--- a/fs/smb/client/cifsfs.c
+++ b/fs/smb/client/cifsfs.c
@@ -1664,7 +1664,7 @@ cifs_init_inodecache(void)
        cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
                                              sizeof(struct cifsInodeInfo),
                                              0, (SLAB_RECLAIM_ACCOUNT|
-                                               SLAB_MEM_SPREAD|SLAB_ACCOUNT),
+                                               SLAB_ACCOUNT),
                                              cifs_init_once);
        if (cifs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/fs/tracefs/inode.c b/fs/tracefs/inode.c
index d65ffad..5545e6b 100644 (file)
--- a/fs/tracefs/inode.c
+++ b/fs/tracefs/inode.c
@@ -731,7 +731,6 @@ static int __init tracefs_init(void)
        tracefs_inode_cachep = kmem_cache_create("tracefs_inode_cache",
                                                 sizeof(struct tracefs_inode),
                                                 0, (SLAB_RECLAIM_ACCOUNT|
-                                                    SLAB_MEM_SPREAD|
                                                     SLAB_ACCOUNT),
                                                 init_once);
        if (!tracefs_inode_cachep)

diff --git a/fs/ubifs/super.c b/fs/ubifs/super.c
index d288104..7f4031a 100644 (file)
--- a/fs/ubifs/super.c
+++ b/fs/ubifs/super.c
@@ -2434,8 +2434,8 @@ static int __init ubifs_init(void)
 
        ubifs_inode_slab = kmem_cache_create("ubifs_inode_slab",
                                sizeof(struct ubifs_inode), 0,
-                               SLAB_MEM_SPREAD | SLAB_RECLAIM_ACCOUNT |
-                               SLAB_ACCOUNT, &inode_slab_ctor);
+                               SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
+                               &inode_slab_ctor);
        if (!ubifs_inode_slab)
                return -ENOMEM;
 

diff --git a/fs/udf/super.c b/fs/udf/super.c
index 928a04d..6f420f4 100644 (file)
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -177,7 +177,6 @@ static int __init init_inodecache(void)
        udf_inode_cachep = kmem_cache_create("udf_inode_cache",
                                             sizeof(struct udf_inode_info),
                                             0, (SLAB_RECLAIM_ACCOUNT |
-                                                SLAB_MEM_SPREAD |
                                                 SLAB_ACCOUNT),
                                             init_once);
        if (!udf_inode_cachep)

diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index a480810..44666af 100644 (file)
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -1470,8 +1470,7 @@ static int __init init_inodecache(void)
 {
        ufs_inode_cachep = kmem_cache_create_usercopy("ufs_inode_cache",
                                sizeof(struct ufs_inode_info), 0,
-                               (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
-                                       SLAB_ACCOUNT),
+                               (SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT),
                                offsetof(struct ufs_inode_info, i_u1.i_symlink),
                                sizeof_field(struct ufs_inode_info,
                                        i_u1.i_symlink),

diff --git a/fs/vboxsf/super.c b/fs/vboxsf/super.c
index 1fb8f4d..cabe8ac 100644 (file)
--- a/fs/vboxsf/super.c
+++ b/fs/vboxsf/super.c
@@ -339,8 +339,7 @@ static int vboxsf_setup(void)
        vboxsf_inode_cachep =
                kmem_cache_create("vboxsf_inode_cache",
                                  sizeof(struct vboxsf_inode), 0,
-                                 (SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD |
-                                  SLAB_ACCOUNT),
+                                 SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
                                  vboxsf_inode_init_once);
        if (!vboxsf_inode_cachep) {
                err = -ENOMEM;

diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 00fbd5b..59c8c05 100644 (file)
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -2043,8 +2043,7 @@ xfs_init_caches(void)
 
        xfs_buf_cache = kmem_cache_create("xfs_buf", sizeof(struct xfs_buf), 0,
                                         SLAB_HWCACHE_ALIGN |
-                                        SLAB_RECLAIM_ACCOUNT |
-                                        SLAB_MEM_SPREAD,
+                                        SLAB_RECLAIM_ACCOUNT,
                                         NULL);
        if (!xfs_buf_cache)
                goto out;
@@ -2109,14 +2108,14 @@ xfs_init_caches(void)
                                           sizeof(struct xfs_inode), 0,
                                           (SLAB_HWCACHE_ALIGN |
                                            SLAB_RECLAIM_ACCOUNT |
-                                           SLAB_MEM_SPREAD | SLAB_ACCOUNT),
+                                           SLAB_ACCOUNT),
                                           xfs_fs_inode_init_once);
        if (!xfs_inode_cache)
                goto out_destroy_efi_cache;
 
        xfs_ili_cache = kmem_cache_create("xfs_ili",
                                         sizeof(struct xfs_inode_log_item), 0,
-                                        SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
+                                        SLAB_RECLAIM_ACCOUNT,
                                         NULL);
        if (!xfs_ili_cache)
                goto out_destroy_inode_cache;

diff --git a/fs/zonefs/super.c b/fs/zonefs/super.c
index 236a6d8..c6a124e 100644 (file)
--- a/fs/zonefs/super.c
+++ b/fs/zonefs/super.c
@@ -1422,7 +1422,7 @@ static int __init zonefs_init_inodecache(void)
 {
        zonefs_inode_cachep = kmem_cache_create("zonefs_inode_cache",
                        sizeof(struct zonefs_inode_info), 0,
-                       (SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | SLAB_ACCOUNT),
+                       SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
                        NULL);
        if (zonefs_inode_cachep == NULL)
                return -ENOMEM;

diff --git a/include/linux/slab.h b/include/linux/slab.h
index f632376..e53cbfa 100644 (file)
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -202,9 +202,6 @@ enum _slab_flag_bits {
 #endif
 #define SLAB_TEMPORARY         SLAB_RECLAIM_ACCOUNT    /* Objects are short-lived */
 
-/* Obsolete unused flag, to be removed */
-#define SLAB_MEM_SPREAD                __SLAB_FLAG_UNUSED
-
 /*
  * ZERO_SIZE_PTR will be returned for zero sized kmalloc requests.
  *

diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index dcc2b4f..910a5d8 100644 (file)
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -1490,7 +1490,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|
-                                               SLAB_MEM_SPREAD|SLAB_ACCOUNT),
+                                               SLAB_ACCOUNT),
                                init_once);
        if (!rpc_inode_cachep)
                return -ENOMEM;