From: Mel Gorman This patch marks a number of allocations that are either short-lived such as network buffers or are reclaimable such as inode allocations. When something like updatedb is called, long-lived and unmovable kernel allocations tend to be spread throughout the address space which increases fragmentation. This patch groups these allocations together as much as possible by adding a new MIGRATE_TYPE. The MIGRATE_RECLAIMABLE type is for allocations that can be reclaimed on demand, but not moved. i.e. they can be migrated by deleting them and re-reading the information from elsewhere. Signed-off-by: Mel Gorman Cc: Andy Whitcroft Cc: Christoph Lameter Signed-off-by: Andrew Morton --- drivers/block/acsi_slm.c | 2 +- fs/buffer.c | 3 ++- fs/dcache.c | 2 +- fs/jbd/journal.c | 4 ++-- fs/jbd/revoke.c | 8 ++++++-- fs/proc/base.c | 13 +++++++------ fs/proc/generic.c | 2 +- include/linux/gfp.h | 18 +++++++++++++++--- include/linux/mmzone.h | 6 ++++-- include/linux/pageblock-flags.h | 2 +- include/linux/slab.h | 4 +++- kernel/cpuset.c | 2 +- lib/radix-tree.c | 6 ++++-- mm/page_alloc.c | 10 +++++++--- mm/shmem.c | 4 ++-- mm/slab.c | 2 ++ mm/slub.c | 3 +++ net/core/skbuff.c | 18 +++++++++--------- 18 files changed, 71 insertions(+), 38 deletions(-) diff -puN drivers/block/acsi_slm.c~group-short-lived-and-reclaimable-kernel-allocations drivers/block/acsi_slm.c --- a/drivers/block/acsi_slm.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/drivers/block/acsi_slm.c @@ -367,7 +367,7 @@ static ssize_t slm_read( struct file *fi int length; int end; - if (!(page = __get_free_page( GFP_KERNEL ))) + if (!(page = __get_free_page(GFP_TEMPORARY))) return( -ENOMEM ); length = slm_getstats( (char *)page, iminor(node) ); diff -puN fs/buffer.c~group-short-lived-and-reclaimable-kernel-allocations fs/buffer.c --- a/fs/buffer.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/fs/buffer.c @@ -3011,7 +3011,8 @@ static void recalc_bh_state(void) struct buffer_head *alloc_buffer_head(gfp_t gfp_flags) { - struct buffer_head *ret = kmem_cache_zalloc(bh_cachep, gfp_flags); + struct buffer_head *ret = kmem_cache_zalloc(bh_cachep, + set_migrateflags(gfp_flags, __GFP_RECLAIMABLE)); if (ret) { INIT_LIST_HEAD(&ret->b_assoc_buffers); get_cpu_var(bh_accounting).nr++; diff -puN fs/dcache.c~group-short-lived-and-reclaimable-kernel-allocations fs/dcache.c --- a/fs/dcache.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/fs/dcache.c @@ -898,7 +898,7 @@ struct dentry *d_alloc(struct dentry * p struct dentry *dentry; char *dname; - dentry = kmem_cache_alloc(dentry_cache, GFP_KERNEL); + dentry = kmem_cache_alloc(dentry_cache, GFP_KERNEL); if (!dentry) return NULL; diff -puN fs/jbd/journal.c~group-short-lived-and-reclaimable-kernel-allocations fs/jbd/journal.c --- a/fs/jbd/journal.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/fs/jbd/journal.c @@ -1710,7 +1710,7 @@ static int journal_init_journal_head_cac journal_head_cache = kmem_cache_create("journal_head", sizeof(struct journal_head), 0, /* offset */ - 0, /* flags */ + SLAB_TEMPORARY, /* flags */ NULL, /* ctor */ NULL); /* dtor */ retval = 0; @@ -2007,7 +2007,7 @@ static int __init journal_init_handle_ca jbd_handle_cache = kmem_cache_create("journal_handle", sizeof(handle_t), 0, /* offset */ - 0, /* flags */ + SLAB_TEMPORARY, /* flags */ NULL, /* ctor */ NULL); /* dtor */ if (jbd_handle_cache == NULL) { diff -puN fs/jbd/revoke.c~group-short-lived-and-reclaimable-kernel-allocations fs/jbd/revoke.c --- a/fs/jbd/revoke.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/fs/jbd/revoke.c @@ -169,13 +169,17 @@ int __init journal_init_revoke_caches(vo { revoke_record_cache = kmem_cache_create("revoke_record", sizeof(struct jbd_revoke_record_s), - 0, SLAB_HWCACHE_ALIGN, NULL, NULL); + 0, + SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY, + NULL, NULL); if (revoke_record_cache == 0) return -ENOMEM; revoke_table_cache = kmem_cache_create("revoke_table", sizeof(struct jbd_revoke_table_s), - 0, 0, NULL, NULL); + 0, + SLAB_TEMPORARY, + NULL, NULL); if (revoke_table_cache == 0) { kmem_cache_destroy(revoke_record_cache); revoke_record_cache = NULL; diff -puN fs/proc/base.c~group-short-lived-and-reclaimable-kernel-allocations fs/proc/base.c --- a/fs/proc/base.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/fs/proc/base.c @@ -487,7 +487,7 @@ static ssize_t proc_info_read(struct fil count = PROC_BLOCK_SIZE; length = -ENOMEM; - if (!(page = __get_free_page(GFP_KERNEL))) + if (!(page = __get_free_page(GFP_TEMPORARY))) goto out; length = PROC_I(inode)->op.proc_read(task, (char*)page); @@ -527,7 +527,7 @@ static ssize_t mem_read(struct file * fi goto out; ret = -ENOMEM; - page = (char *)__get_free_page(GFP_USER); + page = (char *)__get_free_page(GFP_TEMPORARY); if (!page) goto out; @@ -597,7 +597,7 @@ static ssize_t mem_write(struct file * f goto out; copied = -ENOMEM; - page = (char *)__get_free_page(GFP_USER); + page = (char *)__get_free_page(GFP_TEMPORARY); if (!page) goto out; @@ -783,7 +783,7 @@ static ssize_t proc_loginuid_write(struc /* No partial writes. */ return -EINVAL; } - page = (char*)__get_free_page(GFP_USER); + page = (char*)__get_free_page(GFP_TEMPORARY); if (!page) return -ENOMEM; length = -EFAULT; @@ -951,7 +951,8 @@ static int do_proc_readlink(struct dentr char __user *buffer, int buflen) { struct inode * inode; - char *tmp = (char*)__get_free_page(GFP_KERNEL), *path; + char *tmp = (char*)__get_free_page(GFP_TEMPORARY); + char *path; int len; if (!tmp) @@ -1723,7 +1724,7 @@ static ssize_t proc_pid_attr_write(struc goto out; length = -ENOMEM; - page = (char*)__get_free_page(GFP_USER); + page = (char*)__get_free_page(GFP_TEMPORARY); if (!page) goto out; diff -puN fs/proc/generic.c~group-short-lived-and-reclaimable-kernel-allocations fs/proc/generic.c --- a/fs/proc/generic.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/fs/proc/generic.c @@ -73,7 +73,7 @@ proc_file_read(struct file *file, char _ nbytes = MAX_NON_LFS - pos; dp = PDE(inode); - if (!(page = (char*) __get_free_page(GFP_KERNEL))) + if (!(page = (char*) __get_free_page(GFP_TEMPORARY))) return -ENOMEM; while ((nbytes > 0) && !eof) { diff -puN include/linux/gfp.h~group-short-lived-and-reclaimable-kernel-allocations include/linux/gfp.h --- a/include/linux/gfp.h~group-short-lived-and-reclaimable-kernel-allocations +++ a/include/linux/gfp.h @@ -48,9 +48,10 @@ struct vm_area_struct; #define __GFP_NOMEMALLOC ((__force gfp_t)0x10000u) /* Don't use emergency reserves */ #define __GFP_HARDWALL ((__force gfp_t)0x20000u) /* Enforce hardwall cpuset memory allocs */ #define __GFP_THISNODE ((__force gfp_t)0x40000u)/* No fallback, no policies */ -#define __GFP_MOVABLE ((__force gfp_t)0x80000u) /* Page is movable */ +#define __GFP_RECLAIMABLE ((__force gfp_t)0x80000u) /* Page is reclaimable */ +#define __GFP_MOVABLE ((__force gfp_t)0x100000u) /* Page is movable */ -#define __GFP_BITS_SHIFT 20 /* Room for 20 __GFP_FOO bits */ +#define __GFP_BITS_SHIFT 21 /* Room for 21 __GFP_FOO bits */ #define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1)) /* if you forget to add the bitmask here kernel will crash, period */ @@ -58,7 +59,10 @@ struct vm_area_struct; __GFP_COLD|__GFP_NOWARN|__GFP_REPEAT| \ __GFP_NOFAIL|__GFP_NORETRY|__GFP_COMP| \ __GFP_NOMEMALLOC|__GFP_HARDWALL|__GFP_THISNODE| \ - __GFP_MOVABLE) + __GFP_RECLAIMABLE|__GFP_MOVABLE) + +/* This mask makes up all the page movable related flags */ +#define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE) /* This equals 0, but use constants in case they ever change */ #define GFP_NOWAIT (GFP_ATOMIC & ~__GFP_HIGH) @@ -67,6 +71,8 @@ struct vm_area_struct; #define GFP_NOIO (__GFP_WAIT) #define GFP_NOFS (__GFP_WAIT | __GFP_IO) #define GFP_KERNEL (__GFP_WAIT | __GFP_IO | __GFP_FS) +#define GFP_TEMPORARY (__GFP_WAIT | __GFP_IO | __GFP_FS | \ + __GFP_RECLAIMABLE) #define GFP_USER (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL) #define GFP_HIGHUSER (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL | \ __GFP_HIGHMEM) @@ -113,6 +119,12 @@ static inline enum zone_type gfp_zone(gf return ZONE_NORMAL; } +static inline gfp_t set_migrateflags(gfp_t gfp, gfp_t migrate_flags) +{ + BUG_ON((gfp & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK); + return (gfp & ~(GFP_MOVABLE_MASK)) | migrate_flags; +} + /* * There is only one page-allocator function, and two main namespaces to * it. The alloc_page*() variants return 'struct page *' and as such diff -puN include/linux/mmzone.h~group-short-lived-and-reclaimable-kernel-allocations include/linux/mmzone.h --- a/include/linux/mmzone.h~group-short-lived-and-reclaimable-kernel-allocations +++ a/include/linux/mmzone.h @@ -27,10 +27,12 @@ #ifdef CONFIG_PAGE_GROUP_BY_MOBILITY #define MIGRATE_UNMOVABLE 0 -#define MIGRATE_MOVABLE 1 -#define MIGRATE_TYPES 2 +#define MIGRATE_RECLAIMABLE 1 +#define MIGRATE_MOVABLE 2 +#define MIGRATE_TYPES 3 #else #define MIGRATE_UNMOVABLE 0 +#define MIGRATE_UNRECLAIMABLE 0 #define MIGRATE_MOVABLE 0 #define MIGRATE_TYPES 1 #endif diff -puN include/linux/pageblock-flags.h~group-short-lived-and-reclaimable-kernel-allocations include/linux/pageblock-flags.h --- a/include/linux/pageblock-flags.h~group-short-lived-and-reclaimable-kernel-allocations +++ a/include/linux/pageblock-flags.h @@ -31,7 +31,7 @@ /* Bit indices that affect a whole block of pages */ enum pageblock_bits { - PB_range(PB_migrate, 1), /* 1 bit required for migrate types */ + PB_range(PB_migrate, 2), /* 2 bits required for migrate types */ NR_PAGEBLOCK_BITS }; diff -puN include/linux/slab.h~group-short-lived-and-reclaimable-kernel-allocations include/linux/slab.h --- a/include/linux/slab.h~group-short-lived-and-reclaimable-kernel-allocations +++ a/include/linux/slab.h @@ -24,12 +24,14 @@ #define SLAB_HWCACHE_ALIGN 0x00002000UL /* Align objs on cache lines */ #define SLAB_CACHE_DMA 0x00004000UL /* Use GFP_DMA memory */ #define SLAB_STORE_USER 0x00010000UL /* DEBUG: Store the last owner for bug hunting */ -#define SLAB_RECLAIM_ACCOUNT 0x00020000UL /* Objects are reclaimable */ #define SLAB_PANIC 0x00040000UL /* Panic if kmem_cache_create() fails */ #define SLAB_DESTROY_BY_RCU 0x00080000UL /* Defer freeing slabs to RCU */ #define SLAB_MEM_SPREAD 0x00100000UL /* Spread some memory over cpuset */ #define SLAB_TRACE 0x00200000UL /* Trace allocations and frees */ +/* The following flags affect the page allocator grouping pages by mobility */ +#define SLAB_RECLAIM_ACCOUNT 0x00020000UL /* Objects are reclaimable */ +#define SLAB_TEMPORARY SLAB_RECLAIM_ACCOUNT /* Objects are short-lived */ /* * struct kmem_cache related prototypes */ diff -puN kernel/cpuset.c~group-short-lived-and-reclaimable-kernel-allocations kernel/cpuset.c --- a/kernel/cpuset.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/kernel/cpuset.c @@ -1445,7 +1445,7 @@ static ssize_t cpuset_common_file_read(s ssize_t retval = 0; char *s; - if (!(page = (char *)__get_free_page(GFP_KERNEL))) + if (!(page = (char *)__get_free_page(GFP_TEMPORARY))) return -ENOMEM; s = page; diff -puN lib/radix-tree.c~group-short-lived-and-reclaimable-kernel-allocations lib/radix-tree.c --- a/lib/radix-tree.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/lib/radix-tree.c @@ -93,7 +93,8 @@ radix_tree_node_alloc(struct radix_tree_ struct radix_tree_node *ret; gfp_t gfp_mask = root_gfp_mask(root); - ret = kmem_cache_alloc(radix_tree_node_cachep, gfp_mask); + ret = kmem_cache_alloc(radix_tree_node_cachep, + set_migrateflags(gfp_mask, __GFP_RECLAIMABLE)); if (ret == NULL && !(gfp_mask & __GFP_WAIT)) { struct radix_tree_preload *rtp; @@ -137,7 +138,8 @@ int radix_tree_preload(gfp_t gfp_mask) rtp = &__get_cpu_var(radix_tree_preloads); while (rtp->nr < ARRAY_SIZE(rtp->nodes)) { preempt_enable(); - node = kmem_cache_alloc(radix_tree_node_cachep, gfp_mask); + node = kmem_cache_alloc(radix_tree_node_cachep, + set_migrateflags(gfp_mask, __GFP_RECLAIMABLE)); if (node == NULL) goto out; preempt_disable(); diff -puN mm/page_alloc.c~group-short-lived-and-reclaimable-kernel-allocations mm/page_alloc.c --- a/mm/page_alloc.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/mm/page_alloc.c @@ -155,7 +155,10 @@ static void set_pageblock_migratetype(st static inline int gfpflags_to_migratetype(gfp_t gfp_flags) { - return ((gfp_flags & __GFP_MOVABLE) != 0); + WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK); + + return (((gfp_flags & __GFP_MOVABLE) != 0) << 1) | + ((gfp_flags & __GFP_RECLAIMABLE) != 0); } #else @@ -666,8 +669,9 @@ static int prep_new_page(struct page *pa * the free lists for the desirable migrate type are depleted */ static int fallbacks[MIGRATE_TYPES][MIGRATE_TYPES-1] = { - [MIGRATE_UNMOVABLE] = { MIGRATE_MOVABLE }, - [MIGRATE_MOVABLE] = { MIGRATE_UNMOVABLE }, + [MIGRATE_UNMOVABLE] = { MIGRATE_RECLAIMABLE, MIGRATE_MOVABLE }, + [MIGRATE_RECLAIMABLE] = { MIGRATE_UNMOVABLE, MIGRATE_MOVABLE }, + [MIGRATE_MOVABLE] = { MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE }, }; /* diff -puN mm/shmem.c~group-short-lived-and-reclaimable-kernel-allocations mm/shmem.c --- a/mm/shmem.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/mm/shmem.c @@ -95,9 +95,9 @@ static inline struct page *shmem_dir_all * BLOCKS_PER_PAGE on indirect pages, assume PAGE_CACHE_SIZE: * might be reconsidered if it ever diverges from PAGE_SIZE. * - * __GFP_MOVABLE is masked out as swap vectors cannot move + * Mobility flags are masked out as swap vectors cannot move */ - return alloc_pages((gfp_mask & ~__GFP_MOVABLE) | __GFP_ZERO, + return alloc_pages((gfp_mask & ~GFP_MOVABLE_MASK) | __GFP_ZERO, PAGE_CACHE_SHIFT-PAGE_SHIFT); } diff -puN mm/slab.c~group-short-lived-and-reclaimable-kernel-allocations mm/slab.c --- a/mm/slab.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/mm/slab.c @@ -1637,6 +1637,8 @@ static void *kmem_getpages(struct kmem_c #endif flags |= cachep->gfpflags; + if (cachep->flags & SLAB_RECLAIM_ACCOUNT) + flags |= __GFP_RECLAIMABLE; page = alloc_pages_node(nodeid, flags, cachep->gfporder); if (!page) diff -puN mm/slub.c~group-short-lived-and-reclaimable-kernel-allocations mm/slub.c --- a/mm/slub.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/mm/slub.c @@ -1008,6 +1008,9 @@ static struct page *allocate_slab(struct if (s->flags & SLAB_CACHE_DMA) flags |= SLUB_DMA; + if (s->flags & SLAB_RECLAIM_ACCOUNT) + flags |= __GFP_RECLAIMABLE; + if (node == -1) page = alloc_pages(flags, s->order); else diff -puN net/core/skbuff.c~group-short-lived-and-reclaimable-kernel-allocations net/core/skbuff.c --- a/net/core/skbuff.c~group-short-lived-and-reclaimable-kernel-allocations +++ a/net/core/skbuff.c @@ -2007,16 +2007,16 @@ EXPORT_SYMBOL_GPL(skb_segment); void __init skb_init(void) { skbuff_head_cache = kmem_cache_create("skbuff_head_cache", - sizeof(struct sk_buff), - 0, - SLAB_HWCACHE_ALIGN|SLAB_PANIC, - NULL, NULL); + sizeof(struct sk_buff), + 0, + SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_TEMPORARY, + NULL, NULL); skbuff_fclone_cache = kmem_cache_create("skbuff_fclone_cache", - (2*sizeof(struct sk_buff)) + - sizeof(atomic_t), - 0, - SLAB_HWCACHE_ALIGN|SLAB_PANIC, - NULL, NULL); + (2*sizeof(struct sk_buff)) + + sizeof(atomic_t), + 0, + SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_TEMPORARY, + NULL, NULL); } /** _