tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

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>

Linus Torvalds f88c3fb8 0ea680ed

+51 -68
+1 -2
drivers/dax/super.c
··· 532 532 int rc; 533 533 534 534 dax_cache = kmem_cache_create("dax_cache", sizeof(struct dax_device), 0, 535 - (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 536 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 535 + SLAB_HWCACHE_ALIGN | SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, 537 536 init_once); 538 537 if (!dax_cache) 539 538 return -ENOMEM;
+3 -5
drivers/usb/isp1760/isp1760-hcd.c
··· 2521 2521 int __init isp1760_init_kmem_once(void) 2522 2522 { 2523 2523 urb_listitem_cachep = kmem_cache_create("isp1760_urb_listitem", 2524 - sizeof(struct urb_listitem), 0, SLAB_TEMPORARY | 2525 - SLAB_MEM_SPREAD, NULL); 2524 + sizeof(struct urb_listitem), 0, SLAB_TEMPORARY, NULL); 2526 2525 2527 2526 if (!urb_listitem_cachep) 2528 2527 return -ENOMEM; 2529 2528 2530 2529 qtd_cachep = kmem_cache_create("isp1760_qtd", 2531 - sizeof(struct isp1760_qtd), 0, SLAB_TEMPORARY | 2532 - SLAB_MEM_SPREAD, NULL); 2530 + sizeof(struct isp1760_qtd), 0, SLAB_TEMPORARY, NULL); 2533 2531 2534 2532 if (!qtd_cachep) 2535 2533 goto destroy_urb_listitem; 2536 2534 2537 2535 qh_cachep = kmem_cache_create("isp1760_qh", sizeof(struct isp1760_qh), 2538 - 0, SLAB_TEMPORARY | SLAB_MEM_SPREAD, NULL); 2536 + 0, SLAB_TEMPORARY, NULL); 2539 2537 2540 2538 if (!qh_cachep) 2541 2539 goto destroy_qtd;
+1 -1
fs/9p/v9fs.c
··· 637 637 v9fs_inode_cache = kmem_cache_create("v9fs_inode_cache", 638 638 sizeof(struct v9fs_inode), 639 639 0, (SLAB_RECLAIM_ACCOUNT| 640 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 640 + SLAB_ACCOUNT), 641 641 v9fs_inode_init_once); 642 642 if (!v9fs_inode_cache) 643 643 return -ENOMEM;
+1 -1
fs/adfs/super.c
··· 249 249 adfs_inode_cachep = kmem_cache_create("adfs_inode_cache", 250 250 sizeof(struct adfs_inode_info), 251 251 0, (SLAB_RECLAIM_ACCOUNT| 252 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 252 + SLAB_ACCOUNT), 253 253 init_once); 254 254 if (adfs_inode_cachep == NULL) 255 255 return -ENOMEM;
+1 -2
fs/befs/linuxvfs.c
··· 435 435 { 436 436 befs_inode_cachep = kmem_cache_create_usercopy("befs_inode_cache", 437 437 sizeof(struct befs_inode_info), 0, 438 - (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD| 439 - SLAB_ACCOUNT), 438 + SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, 440 439 offsetof(struct befs_inode_info, 441 440 i_data.symlink), 442 441 sizeof_field(struct befs_inode_info,
+1 -1
fs/bfs/inode.c
··· 259 259 bfs_inode_cachep = kmem_cache_create("bfs_inode_cache", 260 260 sizeof(struct bfs_inode_info), 261 261 0, (SLAB_RECLAIM_ACCOUNT| 262 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 262 + SLAB_ACCOUNT), 263 263 init_once); 264 264 if (bfs_inode_cachep == NULL) 265 265 return -ENOMEM;
+9 -9
fs/ceph/super.c
··· 928 928 ceph_inode_cachep = kmem_cache_create("ceph_inode_info", 929 929 sizeof(struct ceph_inode_info), 930 930 __alignof__(struct ceph_inode_info), 931 - SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD| 932 - SLAB_ACCOUNT, ceph_inode_init_once); 931 + SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, 932 + ceph_inode_init_once); 933 933 if (!ceph_inode_cachep) 934 934 return -ENOMEM; 935 935 936 - ceph_cap_cachep = KMEM_CACHE(ceph_cap, SLAB_MEM_SPREAD); 936 + ceph_cap_cachep = KMEM_CACHE(ceph_cap, 0); 937 937 if (!ceph_cap_cachep) 938 938 goto bad_cap; 939 - ceph_cap_snap_cachep = KMEM_CACHE(ceph_cap_snap, SLAB_MEM_SPREAD); 939 + ceph_cap_snap_cachep = KMEM_CACHE(ceph_cap_snap, 0); 940 940 if (!ceph_cap_snap_cachep) 941 941 goto bad_cap_snap; 942 942 ceph_cap_flush_cachep = KMEM_CACHE(ceph_cap_flush, 943 - SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD); 943 + SLAB_RECLAIM_ACCOUNT); 944 944 if (!ceph_cap_flush_cachep) 945 945 goto bad_cap_flush; 946 946 947 947 ceph_dentry_cachep = KMEM_CACHE(ceph_dentry_info, 948 - SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD); 948 + SLAB_RECLAIM_ACCOUNT); 949 949 if (!ceph_dentry_cachep) 950 950 goto bad_dentry; 951 951 952 - ceph_file_cachep = KMEM_CACHE(ceph_file_info, SLAB_MEM_SPREAD); 952 + ceph_file_cachep = KMEM_CACHE(ceph_file_info, 0); 953 953 if (!ceph_file_cachep) 954 954 goto bad_file; 955 955 956 - ceph_dir_file_cachep = KMEM_CACHE(ceph_dir_file_info, SLAB_MEM_SPREAD); 956 + ceph_dir_file_cachep = KMEM_CACHE(ceph_dir_file_info, 0); 957 957 if (!ceph_dir_file_cachep) 958 958 goto bad_dir_file; 959 959 960 - ceph_mds_request_cachep = KMEM_CACHE(ceph_mds_request, SLAB_MEM_SPREAD); 960 + ceph_mds_request_cachep = KMEM_CACHE(ceph_mds_request, 0); 961 961 if (!ceph_mds_request_cachep) 962 962 goto bad_mds_req; 963 963
+2 -2
fs/coda/inode.c
··· 72 72 { 73 73 coda_inode_cachep = kmem_cache_create("coda_inode_cache", 74 74 sizeof(struct coda_inode_info), 0, 75 - SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD| 76 - SLAB_ACCOUNT, init_once); 75 + SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, 76 + init_once); 77 77 if (coda_inode_cachep == NULL) 78 78 return -ENOMEM; 79 79 return 0;
+1 -1
fs/erofs/super.c
··· 857 857 858 858 erofs_inode_cachep = kmem_cache_create("erofs_inode", 859 859 sizeof(struct erofs_inode), 0, 860 - SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | SLAB_ACCOUNT, 860 + SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, 861 861 erofs_inode_init_once); 862 862 if (!erofs_inode_cachep) 863 863 return -ENOMEM;
+1 -1
fs/exfat/cache.c
··· 46 46 { 47 47 exfat_cachep = kmem_cache_create("exfat_cache", 48 48 sizeof(struct exfat_cache), 49 - 0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, 49 + 0, SLAB_RECLAIM_ACCOUNT, 50 50 exfat_cache_init_once); 51 51 if (!exfat_cachep) 52 52 return -ENOMEM;
+1 -1
fs/exfat/super.c
··· 813 813 814 814 exfat_inode_cachep = kmem_cache_create("exfat_inode_cache", 815 815 sizeof(struct exfat_inode_info), 816 - 0, SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, 816 + 0, SLAB_RECLAIM_ACCOUNT, 817 817 exfat_inode_init_once); 818 818 if (!exfat_inode_cachep) { 819 819 err = -ENOMEM;
+1 -2
fs/ext2/super.c
··· 213 213 { 214 214 ext2_inode_cachep = kmem_cache_create_usercopy("ext2_inode_cache", 215 215 sizeof(struct ext2_inode_info), 0, 216 - (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD| 217 - SLAB_ACCOUNT), 216 + SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, 218 217 offsetof(struct ext2_inode_info, i_data), 219 218 sizeof_field(struct ext2_inode_info, i_data), 220 219 init_once);
+1 -2
fs/ext4/super.c
··· 1500 1500 { 1501 1501 ext4_inode_cachep = kmem_cache_create_usercopy("ext4_inode_cache", 1502 1502 sizeof(struct ext4_inode_info), 0, 1503 - (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD| 1504 - SLAB_ACCOUNT), 1503 + SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, 1505 1504 offsetof(struct ext4_inode_info, i_data), 1506 1505 sizeof_field(struct ext4_inode_info, i_data), 1507 1506 init_once);
+1 -1
fs/fat/cache.c
··· 47 47 { 48 48 fat_cache_cachep = kmem_cache_create("fat_cache", 49 49 sizeof(struct fat_cache), 50 - 0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, 50 + 0, SLAB_RECLAIM_ACCOUNT, 51 51 init_once); 52 52 if (fat_cache_cachep == NULL) 53 53 return -ENOMEM;
+1 -1
fs/fat/inode.c
··· 787 787 fat_inode_cachep = kmem_cache_create("fat_inode_cache", 788 788 sizeof(struct msdos_inode_info), 789 789 0, (SLAB_RECLAIM_ACCOUNT| 790 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 790 + SLAB_ACCOUNT), 791 791 init_once); 792 792 if (fat_inode_cachep == NULL) 793 793 return -ENOMEM;
+1 -1
fs/freevxfs/vxfs_super.c
··· 307 307 308 308 vxfs_inode_cachep = kmem_cache_create_usercopy("vxfs_inode", 309 309 sizeof(struct vxfs_inode_info), 0, 310 - SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, 310 + SLAB_RECLAIM_ACCOUNT, 311 311 offsetof(struct vxfs_inode_info, vii_immed.vi_immed), 312 312 sizeof_field(struct vxfs_inode_info, 313 313 vii_immed.vi_immed),
-1
fs/gfs2/main.c
··· 111 111 gfs2_inode_cachep = kmem_cache_create("gfs2_inode", 112 112 sizeof(struct gfs2_inode), 113 113 0, SLAB_RECLAIM_ACCOUNT| 114 - SLAB_MEM_SPREAD| 115 114 SLAB_ACCOUNT, 116 115 gfs2_init_inode_once); 117 116 if (!gfs2_inode_cachep)
+1 -1
fs/hpfs/super.c
··· 255 255 hpfs_inode_cachep = kmem_cache_create("hpfs_inode_cache", 256 256 sizeof(struct hpfs_inode_info), 257 257 0, (SLAB_RECLAIM_ACCOUNT| 258 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 258 + SLAB_ACCOUNT), 259 259 init_once); 260 260 if (hpfs_inode_cachep == NULL) 261 261 return -ENOMEM;
+1 -1
fs/isofs/inode.c
··· 93 93 isofs_inode_cachep = kmem_cache_create("isofs_inode_cache", 94 94 sizeof(struct iso_inode_info), 95 95 0, (SLAB_RECLAIM_ACCOUNT| 96 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 96 + SLAB_ACCOUNT), 97 97 init_once); 98 98 if (!isofs_inode_cachep) 99 99 return -ENOMEM;
+1 -1
fs/jffs2/super.c
··· 387 387 jffs2_inode_cachep = kmem_cache_create("jffs2_i", 388 388 sizeof(struct jffs2_inode_info), 389 389 0, (SLAB_RECLAIM_ACCOUNT| 390 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 390 + SLAB_ACCOUNT), 391 391 jffs2_i_init_once); 392 392 if (!jffs2_inode_cachep) { 393 393 pr_err("error: Failed to initialise inode cache\n");
+1 -2
fs/nfs/direct.c
··· 1037 1037 { 1038 1038 nfs_direct_cachep = kmem_cache_create("nfs_direct_cache", 1039 1039 sizeof(struct nfs_direct_req), 1040 - 0, (SLAB_RECLAIM_ACCOUNT| 1041 - SLAB_MEM_SPREAD), 1040 + 0, SLAB_RECLAIM_ACCOUNT, 1042 1041 NULL); 1043 1042 if (nfs_direct_cachep == NULL) 1044 1043 return -ENOMEM;
+1 -1
fs/nfs/inode.c
··· 2372 2372 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", 2373 2373 sizeof(struct nfs_inode), 2374 2374 0, (SLAB_RECLAIM_ACCOUNT| 2375 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 2375 + SLAB_ACCOUNT), 2376 2376 init_once); 2377 2377 if (nfs_inode_cachep == NULL) 2378 2378 return -ENOMEM;
+1 -1
fs/nfs/nfs42xattr.c
··· 1017 1017 1018 1018 nfs4_xattr_cache_cachep = kmem_cache_create("nfs4_xattr_cache_cache", 1019 1019 sizeof(struct nfs4_xattr_cache), 0, 1020 - (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD), 1020 + (SLAB_RECLAIM_ACCOUNT), 1021 1021 nfs4_xattr_cache_init_once); 1022 1022 if (nfs4_xattr_cache_cachep == NULL) 1023 1023 return -ENOMEM;
+1 -1
fs/ntfs3/super.c
··· 1825 1825 1826 1826 ntfs_inode_cachep = kmem_cache_create( 1827 1827 "ntfs_inode_cache", sizeof(struct ntfs_inode), 0, 1828 - (SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | SLAB_ACCOUNT), 1828 + (SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT), 1829 1829 init_once); 1830 1830 if (!ntfs_inode_cachep) { 1831 1831 err = -ENOMEM;
+1 -1
fs/ocfs2/dlmfs/dlmfs.c
··· 578 578 dlmfs_inode_cache = kmem_cache_create("dlmfs_inode_cache", 579 579 sizeof(struct dlmfs_inode_private), 580 580 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 581 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 581 + SLAB_ACCOUNT), 582 582 dlmfs_init_once); 583 583 if (!dlmfs_inode_cache) { 584 584 status = -ENOMEM;
+3 -4
fs/ocfs2/super.c
··· 1706 1706 sizeof(struct ocfs2_inode_info), 1707 1707 0, 1708 1708 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 1709 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 1709 + SLAB_ACCOUNT), 1710 1710 ocfs2_inode_init_once); 1711 1711 ocfs2_dquot_cachep = kmem_cache_create("ocfs2_dquot_cache", 1712 1712 sizeof(struct ocfs2_dquot), 1713 1713 0, 1714 - (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 1715 - SLAB_MEM_SPREAD), 1714 + (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT), 1716 1715 NULL); 1717 1716 ocfs2_qf_chunk_cachep = kmem_cache_create("ocfs2_qf_chunk_cache", 1718 1717 sizeof(struct ocfs2_quota_chunk), 1719 1718 0, 1720 - (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD), 1719 + (SLAB_RECLAIM_ACCOUNT), 1721 1720 NULL); 1722 1721 if (!ocfs2_inode_cachep || !ocfs2_dquot_cachep || 1723 1722 !ocfs2_qf_chunk_cachep) {
+1 -1
fs/overlayfs/super.c
··· 1503 1503 ovl_inode_cachep = kmem_cache_create("ovl_inode", 1504 1504 sizeof(struct ovl_inode), 0, 1505 1505 (SLAB_RECLAIM_ACCOUNT| 1506 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 1506 + SLAB_ACCOUNT), 1507 1507 ovl_inode_init_once); 1508 1508 if (ovl_inode_cachep == NULL) 1509 1509 return -ENOMEM;
+1 -1
fs/qnx4/inode.c
··· 378 378 qnx4_inode_cachep = kmem_cache_create("qnx4_inode_cache", 379 379 sizeof(struct qnx4_inode_info), 380 380 0, (SLAB_RECLAIM_ACCOUNT| 381 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 381 + SLAB_ACCOUNT), 382 382 init_once); 383 383 if (qnx4_inode_cachep == NULL) 384 384 return -ENOMEM;
+1 -1
fs/quota/dquot.c
··· 2984 2984 dquot_cachep = kmem_cache_create("dquot", 2985 2985 sizeof(struct dquot), sizeof(unsigned long) * 4, 2986 2986 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 2987 - SLAB_MEM_SPREAD|SLAB_PANIC), 2987 + SLAB_PANIC), 2988 2988 NULL); 2989 2989 2990 2990 order = 0;
+1 -1
fs/smb/client/cifsfs.c
··· 1664 1664 cifs_inode_cachep = kmem_cache_create("cifs_inode_cache", 1665 1665 sizeof(struct cifsInodeInfo), 1666 1666 0, (SLAB_RECLAIM_ACCOUNT| 1667 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 1667 + SLAB_ACCOUNT), 1668 1668 cifs_init_once); 1669 1669 if (cifs_inode_cachep == NULL) 1670 1670 return -ENOMEM;
-1
fs/tracefs/inode.c
··· 731 731 tracefs_inode_cachep = kmem_cache_create("tracefs_inode_cache", 732 732 sizeof(struct tracefs_inode), 733 733 0, (SLAB_RECLAIM_ACCOUNT| 734 - SLAB_MEM_SPREAD| 735 734 SLAB_ACCOUNT), 736 735 init_once); 737 736 if (!tracefs_inode_cachep)
+2 -2
fs/ubifs/super.c
··· 2434 2434 2435 2435 ubifs_inode_slab = kmem_cache_create("ubifs_inode_slab", 2436 2436 sizeof(struct ubifs_inode), 0, 2437 - SLAB_MEM_SPREAD | SLAB_RECLAIM_ACCOUNT | 2438 - SLAB_ACCOUNT, &inode_slab_ctor); 2437 + SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, 2438 + &inode_slab_ctor); 2439 2439 if (!ubifs_inode_slab) 2440 2440 return -ENOMEM; 2441 2441
-1
fs/udf/super.c
··· 177 177 udf_inode_cachep = kmem_cache_create("udf_inode_cache", 178 178 sizeof(struct udf_inode_info), 179 179 0, (SLAB_RECLAIM_ACCOUNT | 180 - SLAB_MEM_SPREAD | 181 180 SLAB_ACCOUNT), 182 181 init_once); 183 182 if (!udf_inode_cachep)
+1 -2
fs/ufs/super.c
··· 1470 1470 { 1471 1471 ufs_inode_cachep = kmem_cache_create_usercopy("ufs_inode_cache", 1472 1472 sizeof(struct ufs_inode_info), 0, 1473 - (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD| 1474 - SLAB_ACCOUNT), 1473 + (SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT), 1475 1474 offsetof(struct ufs_inode_info, i_u1.i_symlink), 1476 1475 sizeof_field(struct ufs_inode_info, 1477 1476 i_u1.i_symlink),
+1 -2
fs/vboxsf/super.c
··· 339 339 vboxsf_inode_cachep = 340 340 kmem_cache_create("vboxsf_inode_cache", 341 341 sizeof(struct vboxsf_inode), 0, 342 - (SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | 343 - SLAB_ACCOUNT), 342 + SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, 344 343 vboxsf_inode_init_once); 345 344 if (!vboxsf_inode_cachep) { 346 345 err = -ENOMEM;
+3 -4
fs/xfs/xfs_super.c
··· 2043 2043 2044 2044 xfs_buf_cache = kmem_cache_create("xfs_buf", sizeof(struct xfs_buf), 0, 2045 2045 SLAB_HWCACHE_ALIGN | 2046 - SLAB_RECLAIM_ACCOUNT | 2047 - SLAB_MEM_SPREAD, 2046 + SLAB_RECLAIM_ACCOUNT, 2048 2047 NULL); 2049 2048 if (!xfs_buf_cache) 2050 2049 goto out; ··· 2108 2109 sizeof(struct xfs_inode), 0, 2109 2110 (SLAB_HWCACHE_ALIGN | 2110 2111 SLAB_RECLAIM_ACCOUNT | 2111 - SLAB_MEM_SPREAD | SLAB_ACCOUNT), 2112 + SLAB_ACCOUNT), 2112 2113 xfs_fs_inode_init_once); 2113 2114 if (!xfs_inode_cache) 2114 2115 goto out_destroy_efi_cache; 2115 2116 2116 2117 xfs_ili_cache = kmem_cache_create("xfs_ili", 2117 2118 sizeof(struct xfs_inode_log_item), 0, 2118 - SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, 2119 + SLAB_RECLAIM_ACCOUNT, 2119 2120 NULL); 2120 2121 if (!xfs_ili_cache) 2121 2122 goto out_destroy_inode_cache;
+1 -1
fs/zonefs/super.c
··· 1422 1422 { 1423 1423 zonefs_inode_cachep = kmem_cache_create("zonefs_inode_cache", 1424 1424 sizeof(struct zonefs_inode_info), 0, 1425 - (SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | SLAB_ACCOUNT), 1425 + SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT, 1426 1426 NULL); 1427 1427 if (zonefs_inode_cachep == NULL) 1428 1428 return -ENOMEM;
-3
include/linux/slab.h
··· 202 202 #endif 203 203 #define SLAB_TEMPORARY SLAB_RECLAIM_ACCOUNT /* Objects are short-lived */ 204 204 205 - /* Obsolete unused flag, to be removed */ 206 - #define SLAB_MEM_SPREAD __SLAB_FLAG_UNUSED 207 - 208 205 /* 209 206 * ZERO_SIZE_PTR will be returned for zero sized kmalloc requests. 210 207 *
+1 -1
net/sunrpc/rpc_pipe.c
··· 1490 1490 rpc_inode_cachep = kmem_cache_create("rpc_inode_cache", 1491 1491 sizeof(struct rpc_inode), 1492 1492 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 1493 - SLAB_MEM_SPREAD|SLAB_ACCOUNT), 1493 + SLAB_ACCOUNT), 1494 1494 init_once); 1495 1495 if (!rpc_inode_cachep) 1496 1496 return -ENOMEM;