UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

kmemcg: account certain kmem allocations to memcg 

Mark those kmem allocations that are known to be easily triggered from
userspace as __GFP_ACCOUNT/SLAB_ACCOUNT, which makes them accounted to
memcg.  For the list, see below:

 - threadinfo
 - task_struct
 - task_delay_info
 - pid
 - cred
 - mm_struct
 - vm_area_struct and vm_region (nommu)
 - anon_vma and anon_vma_chain
 - signal_struct
 - sighand_struct
 - fs_struct
 - files_struct
 - fdtable and fdtable->full_fds_bits
 - dentry and external_name
 - inode for all filesystems. This is the most tedious part, because
   most filesystems overwrite the alloc_inode method.

The list is far from complete, so feel free to add more objects.
Nevertheless, it should be close to "account everything" approach and
keep most workloads within bounds.  Malevolent users will be able to
breach the limit, but this was possible even with the former "account
everything" approach (simply because it did not account everything in
fact).

[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Vladimir Davydov <vdavydov@virtuozzo.com>
Acked-by: Johannes Weiner <hannes@cmpxchg.org>
Acked-by: Michal Hocko <mhocko@suse.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Greg Thelen <gthelen@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: David Rientjes <rientjes@google.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Vladimir Davydov 2016-01-14 15:18:21 -08:00 committed by Linus Torvalds
parent 37f08dda29
commit 5d097056c9
65 changed files with 114 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/powerpc/platforms/cell/spufs/inode.c
View File

@ -767,7 +767,7 @@ static int __init spufs_init(void)
ret = -ENOMEM; ret = -ENOMEM;
spufs_inode_cache = kmem_cache_create("spufs_inode_cache", spufs_inode_cache = kmem_cache_create("spufs_inode_cache",
sizeof(struct spufs_inode_info), 0, sizeof(struct spufs_inode_info), 0,
SLAB_HWCACHE_ALIGN, spufs_init_once); SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT, spufs_init_once);
if (!spufs_inode_cache) if (!spufs_inode_cache)
goto out; goto out;

3
drivers/staging/lustre/lustre/llite/super25.c
View File

@ -106,7 +106,8 @@ static int __init init_lustre_lite(void)
rc = -ENOMEM; rc = -ENOMEM;
ll_inode_cachep = kmem_cache_create("lustre_inode_cache", ll_inode_cachep = kmem_cache_create("lustre_inode_cache",
sizeof(struct ll_inode_info), sizeof(struct ll_inode_info),
0, SLAB_HWCACHE_ALIGN, NULL); 0, SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT,
NULL);
if (ll_inode_cachep == NULL) if (ll_inode_cachep == NULL)
goto out_cache; goto out_cache;

2
fs/9p/v9fs.c
View File

@ -575,7 +575,7 @@ static int v9fs_init_inode_cache(void)
v9fs_inode_cache = kmem_cache_create("v9fs_inode_cache", v9fs_inode_cache = kmem_cache_create("v9fs_inode_cache",
sizeof(struct v9fs_inode), sizeof(struct v9fs_inode),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
v9fs_inode_init_once); v9fs_inode_init_once);
if (!v9fs_inode_cache) if (!v9fs_inode_cache)
return -ENOMEM; return -ENOMEM;

2
fs/adfs/super.c
View File

@ -271,7 +271,7 @@ static int __init init_inodecache(void)
adfs_inode_cachep = kmem_cache_create("adfs_inode_cache", adfs_inode_cachep = kmem_cache_create("adfs_inode_cache",
sizeof(struct adfs_inode_info), sizeof(struct adfs_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (adfs_inode_cachep == NULL) if (adfs_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

2
fs/affs/super.c
View File

@ -132,7 +132,7 @@ static int __init init_inodecache(void)
affs_inode_cachep = kmem_cache_create("affs_inode_cache", affs_inode_cachep = kmem_cache_create("affs_inode_cache",
sizeof(struct affs_inode_info), sizeof(struct affs_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (affs_inode_cachep == NULL) if (affs_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

2
fs/afs/super.c
View File

@ -91,7 +91,7 @@ int __init afs_fs_init(void)
afs_inode_cachep = kmem_cache_create("afs_inode_cache", afs_inode_cachep = kmem_cache_create("afs_inode_cache",
sizeof(struct afs_vnode), sizeof(struct afs_vnode),
0, 0,
SLAB_HWCACHE_ALIGN, SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT,
afs_i_init_once); afs_i_init_once);
if (!afs_inode_cachep) { if (!afs_inode_cachep) {
printk(KERN_NOTICE "kAFS: Failed to allocate inode cache\n"); printk(KERN_NOTICE "kAFS: Failed to allocate inode cache\n");

2
fs/befs/linuxvfs.c
View File

@ -434,7 +434,7 @@ befs_init_inodecache(void)
befs_inode_cachep = kmem_cache_create("befs_inode_cache", befs_inode_cachep = kmem_cache_create("befs_inode_cache",
sizeof (struct befs_inode_info), sizeof (struct befs_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (befs_inode_cachep == NULL) { if (befs_inode_cachep == NULL) {
pr_err("%s: Couldn't initialize inode slabcache\n", __func__); pr_err("%s: Couldn't initialize inode slabcache\n", __func__);

2
fs/bfs/inode.c
View File

@ -270,7 +270,7 @@ static int __init init_inodecache(void)
bfs_inode_cachep = kmem_cache_create("bfs_inode_cache", bfs_inode_cachep = kmem_cache_create("bfs_inode_cache",
sizeof(struct bfs_inode_info), sizeof(struct bfs_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (bfs_inode_cachep == NULL) if (bfs_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

2
fs/block_dev.c
View File

@ -595,7 +595,7 @@ void __init bdev_cache_init(void)
bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode), bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode),
0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD|SLAB_PANIC), SLAB_MEM_SPREAD|SLAB_ACCOUNT|SLAB_PANIC),
init_once); init_once);
err = register_filesystem(&bd_type); err = register_filesystem(&bd_type);
if (err) if (err)

3
fs/btrfs/inode.c
View File

@ -9161,7 +9161,8 @@ int btrfs_init_cachep(void)
{ {
btrfs_inode_cachep = kmem_cache_create("btrfs_inode", btrfs_inode_cachep = kmem_cache_create("btrfs_inode",
sizeof(struct btrfs_inode), 0, sizeof(struct btrfs_inode), 0,
SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, init_once); SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD | SLAB_ACCOUNT,
init_once);
if (!btrfs_inode_cachep) if (!btrfs_inode_cachep)
goto fail; goto fail;

4
fs/ceph/super.c
View File

@ -639,8 +639,8 @@ static int __init init_caches(void)
ceph_inode_cachep = kmem_cache_create("ceph_inode_info", ceph_inode_cachep = kmem_cache_create("ceph_inode_info",
sizeof(struct ceph_inode_info), sizeof(struct ceph_inode_info),
__alignof__(struct ceph_inode_info), __alignof__(struct ceph_inode_info),
(SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD), SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
ceph_inode_init_once); SLAB_ACCOUNT, ceph_inode_init_once);
if (ceph_inode_cachep == NULL) if (ceph_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

2
fs/cifs/cifsfs.c
View File

@ -1092,7 +1092,7 @@ cifs_init_inodecache(void)
cifs_inode_cachep = kmem_cache_create("cifs_inode_cache", cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
sizeof(struct cifsInodeInfo), sizeof(struct cifsInodeInfo),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
cifs_init_once); cifs_init_once);
if (cifs_inode_cachep == NULL) if (cifs_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

6
fs/coda/inode.c
View File

@ -74,9 +74,9 @@ static void init_once(void *foo)
int __init coda_init_inodecache(void) int __init coda_init_inodecache(void)
{ {
coda_inode_cachep = kmem_cache_create("coda_inode_cache", coda_inode_cachep = kmem_cache_create("coda_inode_cache",
sizeof(struct coda_inode_info), sizeof(struct coda_inode_info), 0,
0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
init_once); SLAB_ACCOUNT, init_once);
if (coda_inode_cachep == NULL) if (coda_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;
return 0; return 0;

5
fs/dcache.c
View File

@ -1571,7 +1571,8 @@ struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
dentry->d_iname[DNAME_INLINE_LEN-1] = 0; dentry->d_iname[DNAME_INLINE_LEN-1] = 0;
if (name->len > DNAME_INLINE_LEN-1) { if (name->len > DNAME_INLINE_LEN-1) {
size_t size = offsetof(struct external_name, name[1]); size_t size = offsetof(struct external_name, name[1]);
struct external_name *p = kmalloc(size + name->len, GFP_KERNEL); struct external_name *p = kmalloc(size + name->len,
GFP_KERNEL_ACCOUNT);
if (!p) { if (!p) {
kmem_cache_free(dentry_cache, dentry); kmem_cache_free(dentry_cache, dentry);
return NULL; return NULL;
@ -3415,7 +3416,7 @@ static void __init dcache_init(void)
* of the dcache. * of the dcache.
*/ */
dentry_cache = KMEM_CACHE(dentry, dentry_cache = KMEM_CACHE(dentry,
SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD); SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD|SLAB_ACCOUNT);
/* Hash may have been set up in dcache_init_early */ /* Hash may have been set up in dcache_init_early */
if (!hashdist) if (!hashdist)

6
fs/ecryptfs/main.c
View File

@ -663,6 +663,7 @@ static struct ecryptfs_cache_info {
struct kmem_cache **cache; struct kmem_cache **cache;
const char *name; const char *name;
size_t size; size_t size;
unsigned long flags;
void (*ctor)(void *obj); void (*ctor)(void *obj);
} ecryptfs_cache_infos[] = { } ecryptfs_cache_infos[] = {
{ {
@ -684,6 +685,7 @@ static struct ecryptfs_cache_info {
.cache = &ecryptfs_inode_info_cache, .cache = &ecryptfs_inode_info_cache,
.name = "ecryptfs_inode_cache", .name = "ecryptfs_inode_cache",
.size = sizeof(struct ecryptfs_inode_info), .size = sizeof(struct ecryptfs_inode_info),
.flags = SLAB_ACCOUNT,
.ctor = inode_info_init_once, .ctor = inode_info_init_once,
}, },
{ {
@ -755,8 +757,8 @@ static int ecryptfs_init_kmem_caches(void)
struct ecryptfs_cache_info *info; struct ecryptfs_cache_info *info;
info = &ecryptfs_cache_infos[i]; info = &ecryptfs_cache_infos[i];
*(info->cache) = kmem_cache_create(info->name, info->size, *(info->cache) = kmem_cache_create(info->name, info->size, 0,
0, SLAB_HWCACHE_ALIGN, info->ctor); SLAB_HWCACHE_ALIGN | info->flags, info->ctor);
if (!*(info->cache)) { if (!*(info->cache)) {
ecryptfs_free_kmem_caches(); ecryptfs_free_kmem_caches();
ecryptfs_printk(KERN_WARNING, "%s: " ecryptfs_printk(KERN_WARNING, "%s: "

6
fs/efs/super.c
View File

@ -94,9 +94,9 @@ static void init_once(void *foo)
static int __init init_inodecache(void) static int __init init_inodecache(void)
{ {
efs_inode_cachep = kmem_cache_create("efs_inode_cache", efs_inode_cachep = kmem_cache_create("efs_inode_cache",
sizeof(struct efs_inode_info), sizeof(struct efs_inode_info), 0,
0, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
init_once); SLAB_ACCOUNT, init_once);
if (efs_inode_cachep == NULL) if (efs_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;
return 0; return 0;

4
fs/exofs/super.c
View File

@ -194,8 +194,8 @@ static int init_inodecache(void)
{ {
exofs_inode_cachep = kmem_cache_create("exofs_inode_cache", exofs_inode_cachep = kmem_cache_create("exofs_inode_cache",
sizeof(struct exofs_i_info), 0, sizeof(struct exofs_i_info), 0,
SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD |
exofs_init_once); SLAB_ACCOUNT, exofs_init_once);
if (exofs_inode_cachep == NULL) if (exofs_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;
return 0; return 0;

2
fs/ext2/super.c
View File

@ -203,7 +203,7 @@ static int __init init_inodecache(void)
ext2_inode_cachep = kmem_cache_create("ext2_inode_cache", ext2_inode_cachep = kmem_cache_create("ext2_inode_cache",
sizeof(struct ext2_inode_info), sizeof(struct ext2_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (ext2_inode_cachep == NULL) if (ext2_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

2
fs/ext4/super.c
View File

@ -966,7 +966,7 @@ static int __init init_inodecache(void)
ext4_inode_cachep = kmem_cache_create("ext4_inode_cache", ext4_inode_cachep = kmem_cache_create("ext4_inode_cache",
sizeof(struct ext4_inode_info), sizeof(struct ext4_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (ext4_inode_cachep == NULL) if (ext4_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

5
fs/f2fs/super.c
View File

@ -1541,8 +1541,9 @@ MODULE_ALIAS_FS("f2fs");
static int __init init_inodecache(void) static int __init init_inodecache(void)
{ {
f2fs_inode_cachep = f2fs_kmem_cache_create("f2fs_inode_cache", f2fs_inode_cachep = kmem_cache_create("f2fs_inode_cache",
sizeof(struct f2fs_inode_info)); sizeof(struct f2fs_inode_info), 0,
SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT, NULL);
if (!f2fs_inode_cachep) if (!f2fs_inode_cachep)
return -ENOMEM; return -ENOMEM;
return 0; return 0;

2
fs/fat/inode.c
View File

@ -677,7 +677,7 @@ static int __init fat_init_inodecache(void)
fat_inode_cachep = kmem_cache_create("fat_inode_cache", fat_inode_cachep = kmem_cache_create("fat_inode_cache",
sizeof(struct msdos_inode_info), sizeof(struct msdos_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (fat_inode_cachep == NULL) if (fat_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

7
fs/file.c
View File

@ -37,11 +37,12 @@ static void *alloc_fdmem(size_t size)
* vmalloc() if the allocation size will be considered "large" by the VM. * vmalloc() if the allocation size will be considered "large" by the VM.
*/ */
if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER)) { if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER)) {
void *data = kmalloc(size, GFP_KERNEL|__GFP_NOWARN|__GFP_NORETRY); void *data = kmalloc(size, GFP_KERNEL_ACCOUNT |
__GFP_NOWARN | __GFP_NORETRY);
if (data != NULL) if (data != NULL)
return data; return data;
} }
return vmalloc(size); return __vmalloc(size, GFP_KERNEL_ACCOUNT | __GFP_HIGHMEM, PAGE_KERNEL);
} }
static void __free_fdtable(struct fdtable *fdt) static void __free_fdtable(struct fdtable *fdt)
@ -126,7 +127,7 @@ static struct fdtable * alloc_fdtable(unsigned int nr)
if (unlikely(nr > sysctl_nr_open)) if (unlikely(nr > sysctl_nr_open))
nr = ((sysctl_nr_open - 1) | (BITS_PER_LONG - 1)) + 1; nr = ((sysctl_nr_open - 1) | (BITS_PER_LONG - 1)) + 1;
fdt = kmalloc(sizeof(struct fdtable), GFP_KERNEL); fdt = kmalloc(sizeof(struct fdtable), GFP_KERNEL_ACCOUNT);
if (!fdt) if (!fdt)
goto out; goto out;
fdt->max_fds = nr; fdt->max_fds = nr;

4
fs/fuse/inode.c
View File

@ -1255,8 +1255,8 @@ static int __init fuse_fs_init(void)
int err; int err;
fuse_inode_cachep = kmem_cache_create("fuse_inode", fuse_inode_cachep = kmem_cache_create("fuse_inode",
sizeof(struct fuse_inode), sizeof(struct fuse_inode), 0,
0, SLAB_HWCACHE_ALIGN, SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT,
fuse_inode_init_once); fuse_inode_init_once);
err = -ENOMEM; err = -ENOMEM;
if (!fuse_inode_cachep) if (!fuse_inode_cachep)

3
fs/gfs2/main.c
View File

@ -114,7 +114,8 @@ static int __init init_gfs2_fs(void)
gfs2_inode_cachep = kmem_cache_create("gfs2_inode", gfs2_inode_cachep = kmem_cache_create("gfs2_inode",
sizeof(struct gfs2_inode), sizeof(struct gfs2_inode),
0, SLAB_RECLAIM_ACCOUNT| 0, SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD, SLAB_MEM_SPREAD|
SLAB_ACCOUNT,
gfs2_init_inode_once); gfs2_init_inode_once);
if (!gfs2_inode_cachep) if (!gfs2_inode_cachep)
goto fail; goto fail;

4
fs/hfs/super.c
View File

@ -483,8 +483,8 @@ static int __init init_hfs_fs(void)
int err; int err;
hfs_inode_cachep = kmem_cache_create("hfs_inode_cache", hfs_inode_cachep = kmem_cache_create("hfs_inode_cache",
sizeof(struct hfs_inode_info), 0, SLAB_HWCACHE_ALIGN, sizeof(struct hfs_inode_info), 0,
hfs_init_once); SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT, hfs_init_once);
if (!hfs_inode_cachep) if (!hfs_inode_cachep)
return -ENOMEM; return -ENOMEM;
err = register_filesystem(&hfs_fs_type); err = register_filesystem(&hfs_fs_type);

2
fs/hfsplus/super.c
View File

@ -663,7 +663,7 @@ static int __init init_hfsplus_fs(void)
int err; int err;
hfsplus_inode_cachep = kmem_cache_create("hfsplus_icache", hfsplus_inode_cachep = kmem_cache_create("hfsplus_icache",
HFSPLUS_INODE_SIZE, 0, SLAB_HWCACHE_ALIGN, HFSPLUS_INODE_SIZE, 0, SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT,
hfsplus_init_once); hfsplus_init_once);
if (!hfsplus_inode_cachep) if (!hfsplus_inode_cachep)
return -ENOMEM; return -ENOMEM;

2
fs/hostfs/hostfs_kern.c
View File

@ -223,7 +223,7 @@ static struct inode *hostfs_alloc_inode(struct super_block *sb)
{ {
struct hostfs_inode_info *hi; struct hostfs_inode_info *hi;
hi = kmalloc(sizeof(*hi), GFP_KERNEL); hi = kmalloc(sizeof(*hi), GFP_KERNEL_ACCOUNT);
if (hi == NULL) if (hi == NULL)
return NULL; return NULL;
hi->fd = -1; hi->fd = -1;

2
fs/hpfs/super.c
View File

@ -261,7 +261,7 @@ static int init_inodecache(void)
hpfs_inode_cachep = kmem_cache_create("hpfs_inode_cache", hpfs_inode_cachep = kmem_cache_create("hpfs_inode_cache",
sizeof(struct hpfs_inode_info), sizeof(struct hpfs_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (hpfs_inode_cachep == NULL) if (hpfs_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

2
fs/hugetlbfs/inode.c
View File

@ -1322,7 +1322,7 @@ static int __init init_hugetlbfs_fs(void)
error = -ENOMEM; error = -ENOMEM;
hugetlbfs_inode_cachep = kmem_cache_create("hugetlbfs_inode_cache", hugetlbfs_inode_cachep = kmem_cache_create("hugetlbfs_inode_cache",
sizeof(struct hugetlbfs_inode_info), sizeof(struct hugetlbfs_inode_info),
0, 0, init_once); 0, SLAB_ACCOUNT, init_once);
if (hugetlbfs_inode_cachep == NULL) if (hugetlbfs_inode_cachep == NULL)
goto out2; goto out2;

2
fs/inode.c
View File

@ -1883,7 +1883,7 @@ void __init inode_init(void)
sizeof(struct inode), sizeof(struct inode),
0, 0,
(SLAB_RECLAIM_ACCOUNT|SLAB_PANIC| (SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
/* Hash may have been set up in inode_init_early */ /* Hash may have been set up in inode_init_early */

2
fs/isofs/inode.c
View File

@ -94,7 +94,7 @@ static int __init init_inodecache(void)
isofs_inode_cachep = kmem_cache_create("isofs_inode_cache", isofs_inode_cachep = kmem_cache_create("isofs_inode_cache",
sizeof(struct iso_inode_info), sizeof(struct iso_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (isofs_inode_cachep == NULL) if (isofs_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

2
fs/jffs2/super.c
View File

@ -387,7 +387,7 @@ static int __init init_jffs2_fs(void)
jffs2_inode_cachep = kmem_cache_create("jffs2_i", jffs2_inode_cachep = kmem_cache_create("jffs2_i",
sizeof(struct jffs2_inode_info), sizeof(struct jffs2_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
jffs2_i_init_once); jffs2_i_init_once);
if (!jffs2_inode_cachep) { if (!jffs2_inode_cachep) {
pr_err("error: Failed to initialise inode cache\n"); pr_err("error: Failed to initialise inode cache\n");

2
fs/jfs/super.c
View File

@ -898,7 +898,7 @@ static int __init init_jfs_fs(void)
jfs_inode_cachep = jfs_inode_cachep =
kmem_cache_create("jfs_ip", sizeof(struct jfs_inode_info), 0, kmem_cache_create("jfs_ip", sizeof(struct jfs_inode_info), 0,
SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|SLAB_ACCOUNT,
init_once); init_once);
if (jfs_inode_cachep == NULL) if (jfs_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

3
fs/logfs/inode.c
View File

@ -409,7 +409,8 @@ const struct super_operations logfs_super_operations = {
int logfs_init_inode_cache(void) int logfs_init_inode_cache(void)
{ {
logfs_inode_cache = kmem_cache_create("logfs_inode_cache", logfs_inode_cache = kmem_cache_create("logfs_inode_cache",
sizeof(struct logfs_inode), 0, SLAB_RECLAIM_ACCOUNT, sizeof(struct logfs_inode), 0,
SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT,
logfs_init_once); logfs_init_once);
if (!logfs_inode_cache) if (!logfs_inode_cache)
return -ENOMEM; return -ENOMEM;

2
fs/minix/inode.c
View File

@ -91,7 +91,7 @@ static int __init init_inodecache(void)
minix_inode_cachep = kmem_cache_create("minix_inode_cache", minix_inode_cachep = kmem_cache_create("minix_inode_cache",
sizeof(struct minix_inode_info), sizeof(struct minix_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (minix_inode_cachep == NULL) if (minix_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

2
fs/ncpfs/inode.c
View File

@ -82,7 +82,7 @@ static int init_inodecache(void)
ncp_inode_cachep = kmem_cache_create("ncp_inode_cache", ncp_inode_cachep = kmem_cache_create("ncp_inode_cache",
sizeof(struct ncp_inode_info), sizeof(struct ncp_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (ncp_inode_cachep == NULL) if (ncp_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

2
fs/nfs/inode.c
View File

@ -1933,7 +1933,7 @@ static int __init nfs_init_inodecache(void)
nfs_inode_cachep = kmem_cache_create("nfs_inode_cache", nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
sizeof(struct nfs_inode), sizeof(struct nfs_inode),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (nfs_inode_cachep == NULL) if (nfs_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

3
fs/nilfs2/super.c
View File

@ -1416,7 +1416,8 @@ static int __init nilfs_init_cachep(void)
{ {
nilfs_inode_cachep = kmem_cache_create("nilfs2_inode_cache", nilfs_inode_cachep = kmem_cache_create("nilfs2_inode_cache",
sizeof(struct nilfs_inode_info), 0, sizeof(struct nilfs_inode_info), 0,
SLAB_RECLAIM_ACCOUNT, nilfs_inode_init_once); SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT,
nilfs_inode_init_once);
if (!nilfs_inode_cachep) if (!nilfs_inode_cachep)
goto fail; goto fail;

4
fs/ntfs/super.c
View File

@ -3139,8 +3139,8 @@ static int __init init_ntfs_fs(void)
ntfs_big_inode_cache = kmem_cache_create(ntfs_big_inode_cache_name, ntfs_big_inode_cache = kmem_cache_create(ntfs_big_inode_cache_name,
sizeof(big_ntfs_inode), 0, sizeof(big_ntfs_inode), 0,
SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
ntfs_big_inode_init_once); SLAB_ACCOUNT, ntfs_big_inode_init_once);
if (!ntfs_big_inode_cache) { if (!ntfs_big_inode_cache) {
pr_crit("Failed to create %s!\n", ntfs_big_inode_cache_name); pr_crit("Failed to create %s!\n", ntfs_big_inode_cache_name);
goto big_inode_err_out; goto big_inode_err_out;

2
fs/ocfs2/dlmfs/dlmfs.c
View File

@ -638,7 +638,7 @@ static int __init init_dlmfs_fs(void)
dlmfs_inode_cache = kmem_cache_create("dlmfs_inode_cache", dlmfs_inode_cache = kmem_cache_create("dlmfs_inode_cache",
sizeof(struct dlmfs_inode_private), sizeof(struct dlmfs_inode_private),
0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
dlmfs_init_once); dlmfs_init_once);
if (!dlmfs_inode_cache) { if (!dlmfs_inode_cache) {
status = -ENOMEM; status = -ENOMEM;

2
fs/ocfs2/super.c
View File

@ -1766,7 +1766,7 @@ static int ocfs2_initialize_mem_caches(void)
sizeof(struct ocfs2_inode_info), sizeof(struct ocfs2_inode_info),
0, 0,
(SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
ocfs2_inode_init_once); ocfs2_inode_init_once);
ocfs2_dquot_cachep = kmem_cache_create("ocfs2_dquot_cache", ocfs2_dquot_cachep = kmem_cache_create("ocfs2_dquot_cache",
sizeof(struct ocfs2_dquot), sizeof(struct ocfs2_dquot),

2
fs/openpromfs/inode.c
View File

@ -443,7 +443,7 @@ static int __init init_openprom_fs(void)
sizeof(struct op_inode_info), sizeof(struct op_inode_info),
0, 0,
(SLAB_RECLAIM_ACCOUNT | (SLAB_RECLAIM_ACCOUNT |
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD | SLAB_ACCOUNT),
op_inode_init_once); op_inode_init_once);
if (!op_inode_cachep) if (!op_inode_cachep)
return -ENOMEM; return -ENOMEM;

3
fs/proc/inode.c
View File

@ -95,7 +95,8 @@ void __init proc_init_inodecache(void)
proc_inode_cachep = kmem_cache_create("proc_inode_cache", proc_inode_cachep = kmem_cache_create("proc_inode_cache",
sizeof(struct proc_inode), sizeof(struct proc_inode),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD|SLAB_PANIC), SLAB_MEM_SPREAD|SLAB_ACCOUNT|
SLAB_PANIC),
init_once); init_once);
} }

2
fs/qnx4/inode.c
View File

@ -365,7 +365,7 @@ static int init_inodecache(void)
qnx4_inode_cachep = kmem_cache_create("qnx4_inode_cache", qnx4_inode_cachep = kmem_cache_create("qnx4_inode_cache",
sizeof(struct qnx4_inode_info), sizeof(struct qnx4_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (qnx4_inode_cachep == NULL) if (qnx4_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

2
fs/qnx6/inode.c
View File

@ -625,7 +625,7 @@ static int init_inodecache(void)
qnx6_inode_cachep = kmem_cache_create("qnx6_inode_cache", qnx6_inode_cachep = kmem_cache_create("qnx6_inode_cache",
sizeof(struct qnx6_inode_info), sizeof(struct qnx6_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (!qnx6_inode_cachep) if (!qnx6_inode_cachep)
return -ENOMEM; return -ENOMEM;

3
fs/reiserfs/super.c
View File

@ -626,7 +626,8 @@ static int __init init_inodecache(void)
sizeof(struct sizeof(struct
reiserfs_inode_info), reiserfs_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|
SLAB_ACCOUNT),
init_once); init_once);
if (reiserfs_inode_cachep == NULL) if (reiserfs_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

4
fs/romfs/super.c
View File

@ -619,8 +619,8 @@ static int __init init_romfs_fs(void)
romfs_inode_cachep = romfs_inode_cachep =
kmem_cache_create("romfs_i", kmem_cache_create("romfs_i",
sizeof(struct romfs_inode_info), 0, sizeof(struct romfs_inode_info), 0,
SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD |
romfs_i_init_once); SLAB_ACCOUNT, romfs_i_init_once);
if (!romfs_inode_cachep) { if (!romfs_inode_cachep) {
pr_err("Failed to initialise inode cache\n"); pr_err("Failed to initialise inode cache\n");

3
fs/squashfs/super.c
View File

@ -419,7 +419,8 @@ static int __init init_inodecache(void)
{ {
squashfs_inode_cachep = kmem_cache_create("squashfs_inode_cache", squashfs_inode_cachep = kmem_cache_create("squashfs_inode_cache",
sizeof(struct squashfs_inode_info), 0, sizeof(struct squashfs_inode_info), 0,
SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT, init_once); SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|SLAB_ACCOUNT,
init_once);
return squashfs_inode_cachep ? 0 : -ENOMEM; return squashfs_inode_cachep ? 0 : -ENOMEM;
} }

2
fs/sysv/inode.c
View File

@ -346,7 +346,7 @@ int __init sysv_init_icache(void)
{ {
sysv_inode_cachep = kmem_cache_create("sysv_inode_cache", sysv_inode_cachep = kmem_cache_create("sysv_inode_cache",
sizeof(struct sysv_inode_info), 0, sizeof(struct sysv_inode_info), 0,
SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|SLAB_ACCOUNT,
init_once); init_once);
if (!sysv_inode_cachep) if (!sysv_inode_cachep)
return -ENOMEM; return -ENOMEM;

4
fs/ubifs/super.c
View File

@ -2248,8 +2248,8 @@ static int __init ubifs_init(void)
ubifs_inode_slab = kmem_cache_create("ubifs_inode_slab", ubifs_inode_slab = kmem_cache_create("ubifs_inode_slab",
sizeof(struct ubifs_inode), 0, sizeof(struct ubifs_inode), 0,
SLAB_MEM_SPREAD | SLAB_RECLAIM_ACCOUNT, SLAB_MEM_SPREAD | SLAB_RECLAIM_ACCOUNT |
&inode_slab_ctor); SLAB_ACCOUNT, &inode_slab_ctor);
if (!ubifs_inode_slab) if (!ubifs_inode_slab)
return -ENOMEM; return -ENOMEM;

3
fs/udf/super.c
View File

@ -179,7 +179,8 @@ static int __init init_inodecache(void)
udf_inode_cachep = kmem_cache_create("udf_inode_cache", udf_inode_cachep = kmem_cache_create("udf_inode_cache",
sizeof(struct udf_inode_info), sizeof(struct udf_inode_info),
0, (SLAB_RECLAIM_ACCOUNT | 0, (SLAB_RECLAIM_ACCOUNT |
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD |
SLAB_ACCOUNT),
init_once); init_once);
if (!udf_inode_cachep) if (!udf_inode_cachep)
return -ENOMEM; return -ENOMEM;

2
fs/ufs/super.c
View File

@ -1427,7 +1427,7 @@ static int __init init_inodecache(void)
ufs_inode_cachep = kmem_cache_create("ufs_inode_cache", ufs_inode_cachep = kmem_cache_create("ufs_inode_cache",
sizeof(struct ufs_inode_info), sizeof(struct ufs_inode_info),
0, (SLAB_RECLAIM_ACCOUNT| 0, (SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (ufs_inode_cachep == NULL) if (ufs_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

1
fs/xfs/kmem.h
View File

@ -84,6 +84,7 @@ kmem_zalloc(size_t size, xfs_km_flags_t flags)
#define KM_ZONE_HWALIGN SLAB_HWCACHE_ALIGN #define KM_ZONE_HWALIGN SLAB_HWCACHE_ALIGN
#define KM_ZONE_RECLAIM SLAB_RECLAIM_ACCOUNT #define KM_ZONE_RECLAIM SLAB_RECLAIM_ACCOUNT
#define KM_ZONE_SPREAD SLAB_MEM_SPREAD #define KM_ZONE_SPREAD SLAB_MEM_SPREAD
#define KM_ZONE_ACCOUNT SLAB_ACCOUNT
#define kmem_zone kmem_cache #define kmem_zone kmem_cache
#define kmem_zone_t struct kmem_cache #define kmem_zone_t struct kmem_cache

4
fs/xfs/xfs_super.c
View File

@ -1714,8 +1714,8 @@ xfs_init_zones(void)
xfs_inode_zone = xfs_inode_zone =
kmem_zone_init_flags(sizeof(xfs_inode_t), "xfs_inode", kmem_zone_init_flags(sizeof(xfs_inode_t), "xfs_inode",
KM_ZONE_HWALIGN | KM_ZONE_RECLAIM | KM_ZONE_SPREAD, KM_ZONE_HWALIGN | KM_ZONE_RECLAIM | KM_ZONE_SPREAD |
xfs_fs_inode_init_once); KM_ZONE_ACCOUNT, xfs_fs_inode_init_once);
if (!xfs_inode_zone) if (!xfs_inode_zone)
goto out_destroy_efi_zone; goto out_destroy_efi_zone;

5
include/linux/thread_info.h
View File

@ -56,9 +56,10 @@ extern long do_no_restart_syscall(struct restart_block *parm);
#ifdef __KERNEL__ #ifdef __KERNEL__
#ifdef CONFIG_DEBUG_STACK_USAGE #ifdef CONFIG_DEBUG_STACK_USAGE
# define THREADINFO_GFP (GFP_KERNEL | __GFP_NOTRACK | __GFP_ZERO) # define THREADINFO_GFP (GFP_KERNEL_ACCOUNT | __GFP_NOTRACK | \
__GFP_ZERO)
#else #else
# define THREADINFO_GFP (GFP_KERNEL | __GFP_NOTRACK) # define THREADINFO_GFP (GFP_KERNEL_ACCOUNT | __GFP_NOTRACK)
#endif #endif
/* /*

2
ipc/mqueue.c
View File

@ -1438,7 +1438,7 @@ static int __init init_mqueue_fs(void)
mqueue_inode_cachep = kmem_cache_create("mqueue_inode_cache", mqueue_inode_cachep = kmem_cache_create("mqueue_inode_cache",
sizeof(struct mqueue_inode_info), 0, sizeof(struct mqueue_inode_info), 0,
SLAB_HWCACHE_ALIGN, init_once); SLAB_HWCACHE_ALIGN|SLAB_ACCOUNT, init_once);
if (mqueue_inode_cachep == NULL) if (mqueue_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

4
kernel/cred.c
View File

@ -569,8 +569,8 @@ EXPORT_SYMBOL(revert_creds);
void __init cred_init(void) void __init cred_init(void)
{ {
/* allocate a slab in which we can store credentials */ /* allocate a slab in which we can store credentials */
cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred), cred_jar = kmem_cache_create("cred_jar", sizeof(struct cred), 0,
0, SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL); SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_ACCOUNT, NULL);
} }
/** /**

2
kernel/delayacct.c
View File

@ -34,7 +34,7 @@ __setup("nodelayacct", delayacct_setup_disable);
void delayacct_init(void) void delayacct_init(void)
{ {
delayacct_cache = KMEM_CACHE(task_delay_info, SLAB_PANIC); delayacct_cache = KMEM_CACHE(task_delay_info, SLAB_PANIC|SLAB_ACCOUNT);
delayacct_tsk_init(&init_task); delayacct_tsk_init(&init_task);
} }

22
kernel/fork.c
View File

@ -300,9 +300,9 @@ void __init fork_init(void)
#define ARCH_MIN_TASKALIGN L1_CACHE_BYTES #define ARCH_MIN_TASKALIGN L1_CACHE_BYTES
#endif #endif
/* create a slab on which task_structs can be allocated */ /* create a slab on which task_structs can be allocated */
task_struct_cachep = task_struct_cachep = kmem_cache_create("task_struct",
kmem_cache_create("task_struct", arch_task_struct_size, arch_task_struct_size, ARCH_MIN_TASKALIGN,
ARCH_MIN_TASKALIGN, SLAB_PANIC | SLAB_NOTRACK, NULL); SLAB_PANIC|SLAB_NOTRACK|SLAB_ACCOUNT, NULL);
#endif #endif
/* do the arch specific task caches init */ /* do the arch specific task caches init */
@ -1848,16 +1848,19 @@ void __init proc_caches_init(void)
sighand_cachep = kmem_cache_create("sighand_cache", sighand_cachep = kmem_cache_create("sighand_cache",
sizeof(struct sighand_struct), 0, sizeof(struct sighand_struct), 0,
SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU| SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU|
SLAB_NOTRACK, sighand_ctor); SLAB_NOTRACK|SLAB_ACCOUNT, sighand_ctor);
signal_cachep = kmem_cache_create("signal_cache", signal_cachep = kmem_cache_create("signal_cache",
sizeof(struct signal_struct), 0, sizeof(struct signal_struct), 0,
SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL); SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK|SLAB_ACCOUNT,
NULL);
files_cachep = kmem_cache_create("files_cache", files_cachep = kmem_cache_create("files_cache",
sizeof(struct files_struct), 0, sizeof(struct files_struct), 0,
SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL); SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK|SLAB_ACCOUNT,
NULL);
fs_cachep = kmem_cache_create("fs_cache", fs_cachep = kmem_cache_create("fs_cache",
sizeof(struct fs_struct), 0, sizeof(struct fs_struct), 0,
SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL); SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK|SLAB_ACCOUNT,
NULL);
/* /*
* FIXME! The "sizeof(struct mm_struct)" currently includes the * FIXME! The "sizeof(struct mm_struct)" currently includes the
* whole struct cpumask for the OFFSTACK case. We could change * whole struct cpumask for the OFFSTACK case. We could change
@ -1867,8 +1870,9 @@ void __init proc_caches_init(void)
*/ */
mm_cachep = kmem_cache_create("mm_struct", mm_cachep = kmem_cache_create("mm_struct",
sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN, sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,
SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL); SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK|SLAB_ACCOUNT,
vm_area_cachep = KMEM_CACHE(vm_area_struct, SLAB_PANIC); NULL);
vm_area_cachep = KMEM_CACHE(vm_area_struct, SLAB_PANIC|SLAB_ACCOUNT);
mmap_init(); mmap_init();
nsproxy_cache_init(); nsproxy_cache_init();
} }

2
kernel/pid.c
View File

@ -604,5 +604,5 @@ void __init pidmap_init(void)
atomic_dec(&init_pid_ns.pidmap[0].nr_free); atomic_dec(&init_pid_ns.pidmap[0].nr_free);
init_pid_ns.pid_cachep = KMEM_CACHE(pid, init_pid_ns.pid_cachep = KMEM_CACHE(pid,
SLAB_HWCACHE_ALIGN | SLAB_PANIC); SLAB_HWCACHE_ALIGN | SLAB_PANIC | SLAB_ACCOUNT);
} }

2
mm/nommu.c
View File

@ -560,7 +560,7 @@ void __init mmap_init(void)
ret = percpu_counter_init(&vm_committed_as, 0, GFP_KERNEL); ret = percpu_counter_init(&vm_committed_as, 0, GFP_KERNEL);
VM_BUG_ON(ret); VM_BUG_ON(ret);
vm_region_jar = KMEM_CACHE(vm_region, SLAB_PANIC); vm_region_jar = KMEM_CACHE(vm_region, SLAB_PANIC|SLAB_ACCOUNT);
} }
/* /*

6
mm/rmap.c
View File

@ -428,8 +428,10 @@ static void anon_vma_ctor(void *data)
void __init anon_vma_init(void) void __init anon_vma_init(void)
{ {
anon_vma_cachep = kmem_cache_create("anon_vma", sizeof(struct anon_vma), anon_vma_cachep = kmem_cache_create("anon_vma", sizeof(struct anon_vma),
0, SLAB_DESTROY_BY_RCU|SLAB_PANIC, anon_vma_ctor); 0, SLAB_DESTROY_BY_RCU|SLAB_PANIC|SLAB_ACCOUNT,
anon_vma_chain_cachep = KMEM_CACHE(anon_vma_chain, SLAB_PANIC); anon_vma_ctor);
anon_vma_chain_cachep = KMEM_CACHE(anon_vma_chain,
SLAB_PANIC|SLAB_ACCOUNT);
} }
/* /*

2
mm/shmem.c
View File

@ -3064,7 +3064,7 @@ static int shmem_init_inodecache(void)
{ {
shmem_inode_cachep = kmem_cache_create("shmem_inode_cache", shmem_inode_cachep = kmem_cache_create("shmem_inode_cache",
sizeof(struct shmem_inode_info), sizeof(struct shmem_inode_info),
0, SLAB_PANIC, shmem_init_inode); 0, SLAB_PANIC|SLAB_ACCOUNT, shmem_init_inode);
return 0; return 0;
} }

2
net/socket.c
View File

@ -294,7 +294,7 @@ static int init_inodecache(void)
0, 0,
(SLAB_HWCACHE_ALIGN | (SLAB_HWCACHE_ALIGN |
SLAB_RECLAIM_ACCOUNT | SLAB_RECLAIM_ACCOUNT |
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD | SLAB_ACCOUNT),
init_once); init_once);
if (sock_inode_cachep == NULL) if (sock_inode_cachep == NULL)
return -ENOMEM; return -ENOMEM;

2
net/sunrpc/rpc_pipe.c
View File

@ -1500,7 +1500,7 @@ int register_rpc_pipefs(void)
rpc_inode_cachep = kmem_cache_create("rpc_inode_cache", rpc_inode_cachep = kmem_cache_create("rpc_inode_cache",
sizeof(struct rpc_inode), sizeof(struct rpc_inode),
0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT| 0, (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
SLAB_MEM_SPREAD), SLAB_MEM_SPREAD|SLAB_ACCOUNT),
init_once); init_once);
if (!rpc_inode_cachep) if (!rpc_inode_cachep)
return -ENOMEM; return -ENOMEM;