Commit e9aae170 authored by Kefeng Wang's avatar Kefeng Wang Committed by Andrew Morton
Browse files

mm: page_alloc: collect mem statistic into show_mem.c 

Let's move show_mem.c from lib to mm, as it belongs memory subsystem, also
split some memory statistic related functions from page_alloc.c to
show_mem.c, and we cleanup some unneeded include.

There is no functional change.

Link: https://lkml.kernel.org/r/20230516063821.121844-5-wangkefeng.wang@huawei.com


Signed-off-by: default avatarKefeng Wang <wangkefeng.wang@huawei.com>
Cc: David Hildenbrand <david@redhat.com>
Cc: "Huang, Ying" <ying.huang@intel.com>
Cc: Iurii Zaikin <yzaikin@google.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Len Brown <len.brown@intel.com>
Cc: Luis Chamberlain <mcgrof@kernel.org>
Cc: Mike Rapoport (IBM) <rppt@kernel.org>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: Pavel Machek <pavel@ucw.cz>
Cc: Rafael J. Wysocki <rafael@kernel.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
parent 904d5857

lib/Makefile

+1 −1
Original line number Original line Diff line number Diff line
@@ -30,7 +30,7 @@ endif 
lib-y := ctype.o string.o vsprintf.o cmdline.o \

lib-y := ctype.o string.o vsprintf.o cmdline.o \

	 rbtree.o radix-tree.o timerqueue.o xarray.o \

	 rbtree.o radix-tree.o timerqueue.o xarray.o \

	 maple_tree.o idr.o extable.o irq_regs.o argv_split.o \

	 maple_tree.o idr.o extable.o irq_regs.o argv_split.o \

	 flex_proportions.o ratelimit.o show_mem.o \

	 flex_proportions.o ratelimit.o \

	 is_single_threaded.o plist.o decompress.o kobject_uevent.o \

	 is_single_threaded.o plist.o decompress.o kobject_uevent.o \

	 earlycpio.o seq_buf.o siphash.o dec_and_lock.o \

	 earlycpio.o seq_buf.o siphash.o dec_and_lock.o \

	 nmi_backtrace.o win_minmax.o memcat_p.o \

	 nmi_backtrace.o win_minmax.o memcat_p.o \

lib/show_mem.c

deleted100644 → 0
+0 −37
Original line number Original line Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * Generic show_mem() implementation

 *

 * Copyright (C) 2008 Johannes Weiner <hannes@saeurebad.de>

 */



#include <linux/mm.h>

#include <linux/cma.h>



void __show_mem(unsigned int filter, nodemask_t *nodemask, int max_zone_idx)

{

	unsigned long total = 0, reserved = 0, highmem = 0;

	struct zone *zone;



	printk("Mem-Info:\n");

	__show_free_areas(filter, nodemask, max_zone_idx);



	for_each_populated_zone(zone) {



		total += zone->present_pages;

		reserved += zone->present_pages - zone_managed_pages(zone);



		if (is_highmem(zone))

			highmem += zone->present_pages;

	}



	printk("%lu pages RAM\n", total);

	printk("%lu pages HighMem/MovableOnly\n", highmem);

	printk("%lu pages reserved\n", reserved);

#ifdef CONFIG_CMA

	printk("%lu pages cma reserved\n", totalcma_pages);

#endif

#ifdef CONFIG_MEMORY_FAILURE

	printk("%lu pages hwpoisoned\n", atomic_long_read(&num_poisoned_pages));

#endif

}

mm/Makefile

+1 −1
Original line number Original line Diff line number Diff line
@@ -51,7 +51,7 @@ obj-y := filemap.o mempool.o oom_kill.o fadvise.o \ 
			   readahead.o swap.o truncate.o vmscan.o shmem.o \

			   readahead.o swap.o truncate.o vmscan.o shmem.o \

			   util.o mmzone.o vmstat.o backing-dev.o \

			   util.o mmzone.o vmstat.o backing-dev.o \

			   mm_init.o percpu.o slab_common.o \

			   mm_init.o percpu.o slab_common.o \

			   compaction.o \

			   compaction.o show_mem.o\

			   interval_tree.o list_lru.o workingset.o \

			   interval_tree.o list_lru.o workingset.o \

			   debug.o gup.o mmap_lock.o $(mmu-y)

			   debug.o gup.o mmap_lock.o $(mmu-y)

mm/page_alloc.c

+0 −402
Original line number Original line Diff line number Diff line
@@ -18,10 +18,7 @@ 
#include <linux/stddef.h>

#include <linux/stddef.h>

#include <linux/mm.h>

#include <linux/mm.h>

#include <linux/highmem.h>

#include <linux/highmem.h>

#include <linux/swap.h>

#include <linux/swapops.h>

#include <linux/interrupt.h>

#include <linux/interrupt.h>

#include <linux/pagemap.h>

#include <linux/jiffies.h>

#include <linux/jiffies.h>

#include <linux/compiler.h>

#include <linux/compiler.h>

#include <linux/kernel.h>

#include <linux/kernel.h>
@@ -30,8 +27,6 @@ 
#include <linux/module.h>

#include <linux/module.h>

#include <linux/suspend.h>

#include <linux/suspend.h>

#include <linux/pagevec.h>

#include <linux/pagevec.h>

#include <linux/blkdev.h>

#include <linux/slab.h>

#include <linux/ratelimit.h>

#include <linux/ratelimit.h>

#include <linux/oom.h>

#include <linux/oom.h>

#include <linux/topology.h>

#include <linux/topology.h>
@@ -40,19 +35,10 @@ 
#include <linux/cpuset.h>

#include <linux/cpuset.h>

#include <linux/memory_hotplug.h>

#include <linux/memory_hotplug.h>

#include <linux/nodemask.h>

#include <linux/nodemask.h>

#include <linux/vmalloc.h>

#include <linux/vmstat.h>

#include <linux/vmstat.h>

#include <linux/mempolicy.h>

#include <linux/memremap.h>

#include <linux/stop_machine.h>

#include <linux/random.h>

#include <linux/sort.h>

#include <linux/sort.h>

#include <linux/pfn.h>

#include <linux/pfn.h>

#include <linux/backing-dev.h>

#include <linux/fault-inject.h>

#include <linux/fault-inject.h>

#include <linux/page-isolation.h>

#include <linux/debugobjects.h>

#include <linux/kmemleak.h>

#include <linux/compaction.h>

#include <linux/compaction.h>

#include <trace/events/kmem.h>

#include <trace/events/kmem.h>

#include <trace/events/oom.h>

#include <trace/events/oom.h>
@@ -60,12 +46,9 @@ 
#include <linux/mm_inline.h>

#include <linux/mm_inline.h>

#include <linux/mmu_notifier.h>

#include <linux/mmu_notifier.h>

#include <linux/migrate.h>

#include <linux/migrate.h>

#include <linux/hugetlb.h>

#include <linux/sched/rt.h>

#include <linux/sched/mm.h>

#include <linux/sched/mm.h>

#include <linux/page_owner.h>

#include <linux/page_owner.h>

#include <linux/page_table_check.h>

#include <linux/page_table_check.h>

#include <linux/kthread.h>

#include <linux/memcontrol.h>

#include <linux/memcontrol.h>

#include <linux/ftrace.h>

#include <linux/ftrace.h>

#include <linux/lockdep.h>

#include <linux/lockdep.h>
@@ -73,13 +56,10 @@ 
#include <linux/psi.h>

#include <linux/psi.h>

#include <linux/khugepaged.h>

#include <linux/khugepaged.h>

#include <linux/delayacct.h>

#include <linux/delayacct.h>

#include <asm/sections.h>

#include <asm/tlbflush.h>

#include <asm/div64.h>

#include <asm/div64.h>

#include "internal.h"

#include "internal.h"

#include "shuffle.h"

#include "shuffle.h"

#include "page_reporting.h"

#include "page_reporting.h"

#include "swap.h"





/* Free Page Internal flags: for internal, non-pcp variants of free_pages(). */

/* Free Page Internal flags: for internal, non-pcp variants of free_pages(). */

typedef int __bitwise fpi_t;

typedef int __bitwise fpi_t;
@@ -226,11 +206,6 @@ nodemask_t node_states[NR_NODE_STATES] __read_mostly = { 
};

};

EXPORT_SYMBOL(node_states);

EXPORT_SYMBOL(node_states);





atomic_long_t _totalram_pages __read_mostly;

EXPORT_SYMBOL(_totalram_pages);

unsigned long totalreserve_pages __read_mostly;

unsigned long totalcma_pages __read_mostly;



int percpu_pagelist_high_fraction;

int percpu_pagelist_high_fraction;

gfp_t gfp_allowed_mask __read_mostly = GFP_BOOT_MASK;

gfp_t gfp_allowed_mask __read_mostly = GFP_BOOT_MASK;
@@ -5102,383 +5077,6 @@ unsigned long nr_free_buffer_pages(void) 
}

}

EXPORT_SYMBOL_GPL(nr_free_buffer_pages);

EXPORT_SYMBOL_GPL(nr_free_buffer_pages);





static inline void show_node(struct zone *zone)

{

	if (IS_ENABLED(CONFIG_NUMA))

		printk("Node %d ", zone_to_nid(zone));

}



long si_mem_available(void)

{

	long available;

	unsigned long pagecache;

	unsigned long wmark_low = 0;

	unsigned long pages[NR_LRU_LISTS];

	unsigned long reclaimable;

	struct zone *zone;

	int lru;



	for (lru = LRU_BASE; lru < NR_LRU_LISTS; lru++)

		pages[lru] = global_node_page_state(NR_LRU_BASE + lru);



	for_each_zone(zone)

		wmark_low += low_wmark_pages(zone);



	/*

	 * Estimate the amount of memory available for userspace allocations,

	 * without causing swapping or OOM.

	 */

	available = global_zone_page_state(NR_FREE_PAGES) - totalreserve_pages;



	/*

	 * Not all the page cache can be freed, otherwise the system will

	 * start swapping or thrashing. Assume at least half of the page

	 * cache, or the low watermark worth of cache, needs to stay.

	 */

	pagecache = pages[LRU_ACTIVE_FILE] + pages[LRU_INACTIVE_FILE];

	pagecache -= min(pagecache / 2, wmark_low);

	available += pagecache;



	/*

	 * Part of the reclaimable slab and other kernel memory consists of

	 * items that are in use, and cannot be freed. Cap this estimate at the

	 * low watermark.

	 */

	reclaimable = global_node_page_state_pages(NR_SLAB_RECLAIMABLE_B) +

		global_node_page_state(NR_KERNEL_MISC_RECLAIMABLE);

	available += reclaimable - min(reclaimable / 2, wmark_low);



	if (available < 0)

		available = 0;

	return available;

}

EXPORT_SYMBOL_GPL(si_mem_available);



void si_meminfo(struct sysinfo *val)

{

	val->totalram = totalram_pages();

	val->sharedram = global_node_page_state(NR_SHMEM);

	val->freeram = global_zone_page_state(NR_FREE_PAGES);

	val->bufferram = nr_blockdev_pages();

	val->totalhigh = totalhigh_pages();

	val->freehigh = nr_free_highpages();

	val->mem_unit = PAGE_SIZE;

}



EXPORT_SYMBOL(si_meminfo);



#ifdef CONFIG_NUMA

void si_meminfo_node(struct sysinfo *val, int nid)

{

	int zone_type;		/* needs to be signed */

	unsigned long managed_pages = 0;

	unsigned long managed_highpages = 0;

	unsigned long free_highpages = 0;

	pg_data_t *pgdat = NODE_DATA(nid);



	for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++)

		managed_pages += zone_managed_pages(&pgdat->node_zones[zone_type]);

	val->totalram = managed_pages;

	val->sharedram = node_page_state(pgdat, NR_SHMEM);

	val->freeram = sum_zone_node_page_state(nid, NR_FREE_PAGES);

#ifdef CONFIG_HIGHMEM

	for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++) {

		struct zone *zone = &pgdat->node_zones[zone_type];



		if (is_highmem(zone)) {

			managed_highpages += zone_managed_pages(zone);

			free_highpages += zone_page_state(zone, NR_FREE_PAGES);

		}

	}

	val->totalhigh = managed_highpages;

	val->freehigh = free_highpages;

#else

	val->totalhigh = managed_highpages;

	val->freehigh = free_highpages;

#endif

	val->mem_unit = PAGE_SIZE;

}

#endif



/*

 * Determine whether the node should be displayed or not, depending on whether

 * SHOW_MEM_FILTER_NODES was passed to show_free_areas().

 */

static bool show_mem_node_skip(unsigned int flags, int nid, nodemask_t *nodemask)

{

	if (!(flags & SHOW_MEM_FILTER_NODES))

		return false;



	/*

	 * no node mask - aka implicit memory numa policy. Do not bother with

	 * the synchronization - read_mems_allowed_begin - because we do not

	 * have to be precise here.

	 */

	if (!nodemask)

		nodemask = &cpuset_current_mems_allowed;



	return !node_isset(nid, *nodemask);

}



static void show_migration_types(unsigned char type)

{

	static const char types[MIGRATE_TYPES] = {

		[MIGRATE_UNMOVABLE]	= 'U',

		[MIGRATE_MOVABLE]	= 'M',

		[MIGRATE_RECLAIMABLE]	= 'E',

		[MIGRATE_HIGHATOMIC]	= 'H',

#ifdef CONFIG_CMA

		[MIGRATE_CMA]		= 'C',

#endif

#ifdef CONFIG_MEMORY_ISOLATION

		[MIGRATE_ISOLATE]	= 'I',

#endif

	};

	char tmp[MIGRATE_TYPES + 1];

	char *p = tmp;

	int i;



	for (i = 0; i < MIGRATE_TYPES; i++) {

		if (type & (1 << i))

			*p++ = types[i];

	}



	*p = '\0';

	printk(KERN_CONT "(%s) ", tmp);

}



static bool node_has_managed_zones(pg_data_t *pgdat, int max_zone_idx)

{

	int zone_idx;

	for (zone_idx = 0; zone_idx <= max_zone_idx; zone_idx++)

		if (zone_managed_pages(pgdat->node_zones + zone_idx))

			return true;

	return false;

}



/*

 * Show free area list (used inside shift_scroll-lock stuff)

 * We also calculate the percentage fragmentation. We do this by counting the

 * memory on each free list with the exception of the first item on the list.

 *

 * Bits in @filter:

 * SHOW_MEM_FILTER_NODES: suppress nodes that are not allowed by current's

 *   cpuset.

 */

void __show_free_areas(unsigned int filter, nodemask_t *nodemask, int max_zone_idx)

{

	unsigned long free_pcp = 0;

	int cpu, nid;

	struct zone *zone;

	pg_data_t *pgdat;



	for_each_populated_zone(zone) {

		if (zone_idx(zone) > max_zone_idx)

			continue;

		if (show_mem_node_skip(filter, zone_to_nid(zone), nodemask))

			continue;



		for_each_online_cpu(cpu)

			free_pcp += per_cpu_ptr(zone->per_cpu_pageset, cpu)->count;

	}



	printk("active_anon:%lu inactive_anon:%lu isolated_anon:%lu\n"

		" active_file:%lu inactive_file:%lu isolated_file:%lu\n"

		" unevictable:%lu dirty:%lu writeback:%lu\n"

		" slab_reclaimable:%lu slab_unreclaimable:%lu\n"

		" mapped:%lu shmem:%lu pagetables:%lu\n"

		" sec_pagetables:%lu bounce:%lu\n"

		" kernel_misc_reclaimable:%lu\n"

		" free:%lu free_pcp:%lu free_cma:%lu\n",

		global_node_page_state(NR_ACTIVE_ANON),

		global_node_page_state(NR_INACTIVE_ANON),

		global_node_page_state(NR_ISOLATED_ANON),

		global_node_page_state(NR_ACTIVE_FILE),

		global_node_page_state(NR_INACTIVE_FILE),

		global_node_page_state(NR_ISOLATED_FILE),

		global_node_page_state(NR_UNEVICTABLE),

		global_node_page_state(NR_FILE_DIRTY),

		global_node_page_state(NR_WRITEBACK),

		global_node_page_state_pages(NR_SLAB_RECLAIMABLE_B),

		global_node_page_state_pages(NR_SLAB_UNRECLAIMABLE_B),

		global_node_page_state(NR_FILE_MAPPED),

		global_node_page_state(NR_SHMEM),

		global_node_page_state(NR_PAGETABLE),

		global_node_page_state(NR_SECONDARY_PAGETABLE),

		global_zone_page_state(NR_BOUNCE),

		global_node_page_state(NR_KERNEL_MISC_RECLAIMABLE),

		global_zone_page_state(NR_FREE_PAGES),

		free_pcp,

		global_zone_page_state(NR_FREE_CMA_PAGES));



	for_each_online_pgdat(pgdat) {

		if (show_mem_node_skip(filter, pgdat->node_id, nodemask))

			continue;

		if (!node_has_managed_zones(pgdat, max_zone_idx))

			continue;



		printk("Node %d"

			" active_anon:%lukB"

			" inactive_anon:%lukB"

			" active_file:%lukB"

			" inactive_file:%lukB"

			" unevictable:%lukB"

			" isolated(anon):%lukB"

			" isolated(file):%lukB"

			" mapped:%lukB"

			" dirty:%lukB"

			" writeback:%lukB"

			" shmem:%lukB"

#ifdef CONFIG_TRANSPARENT_HUGEPAGE

			" shmem_thp: %lukB"

			" shmem_pmdmapped: %lukB"

			" anon_thp: %lukB"

#endif

			" writeback_tmp:%lukB"

			" kernel_stack:%lukB"

#ifdef CONFIG_SHADOW_CALL_STACK

			" shadow_call_stack:%lukB"

#endif

			" pagetables:%lukB"

			" sec_pagetables:%lukB"

			" all_unreclaimable? %s"

			"\n",

			pgdat->node_id,

			K(node_page_state(pgdat, NR_ACTIVE_ANON)),

			K(node_page_state(pgdat, NR_INACTIVE_ANON)),

			K(node_page_state(pgdat, NR_ACTIVE_FILE)),

			K(node_page_state(pgdat, NR_INACTIVE_FILE)),

			K(node_page_state(pgdat, NR_UNEVICTABLE)),

			K(node_page_state(pgdat, NR_ISOLATED_ANON)),

			K(node_page_state(pgdat, NR_ISOLATED_FILE)),

			K(node_page_state(pgdat, NR_FILE_MAPPED)),

			K(node_page_state(pgdat, NR_FILE_DIRTY)),

			K(node_page_state(pgdat, NR_WRITEBACK)),

			K(node_page_state(pgdat, NR_SHMEM)),

#ifdef CONFIG_TRANSPARENT_HUGEPAGE

			K(node_page_state(pgdat, NR_SHMEM_THPS)),

			K(node_page_state(pgdat, NR_SHMEM_PMDMAPPED)),

			K(node_page_state(pgdat, NR_ANON_THPS)),

#endif

			K(node_page_state(pgdat, NR_WRITEBACK_TEMP)),

			node_page_state(pgdat, NR_KERNEL_STACK_KB),

#ifdef CONFIG_SHADOW_CALL_STACK

			node_page_state(pgdat, NR_KERNEL_SCS_KB),

#endif

			K(node_page_state(pgdat, NR_PAGETABLE)),

			K(node_page_state(pgdat, NR_SECONDARY_PAGETABLE)),

			pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES ?

				"yes" : "no");

	}



	for_each_populated_zone(zone) {

		int i;



		if (zone_idx(zone) > max_zone_idx)

			continue;

		if (show_mem_node_skip(filter, zone_to_nid(zone), nodemask))

			continue;



		free_pcp = 0;

		for_each_online_cpu(cpu)

			free_pcp += per_cpu_ptr(zone->per_cpu_pageset, cpu)->count;



		show_node(zone);

		printk(KERN_CONT

			"%s"

			" free:%lukB"

			" boost:%lukB"

			" min:%lukB"

			" low:%lukB"

			" high:%lukB"

			" reserved_highatomic:%luKB"

			" active_anon:%lukB"

			" inactive_anon:%lukB"

			" active_file:%lukB"

			" inactive_file:%lukB"

			" unevictable:%lukB"

			" writepending:%lukB"

			" present:%lukB"

			" managed:%lukB"

			" mlocked:%lukB"

			" bounce:%lukB"

			" free_pcp:%lukB"

			" local_pcp:%ukB"

			" free_cma:%lukB"

			"\n",

			zone->name,

			K(zone_page_state(zone, NR_FREE_PAGES)),

			K(zone->watermark_boost),

			K(min_wmark_pages(zone)),

			K(low_wmark_pages(zone)),

			K(high_wmark_pages(zone)),

			K(zone->nr_reserved_highatomic),

			K(zone_page_state(zone, NR_ZONE_ACTIVE_ANON)),

			K(zone_page_state(zone, NR_ZONE_INACTIVE_ANON)),

			K(zone_page_state(zone, NR_ZONE_ACTIVE_FILE)),

			K(zone_page_state(zone, NR_ZONE_INACTIVE_FILE)),

			K(zone_page_state(zone, NR_ZONE_UNEVICTABLE)),

			K(zone_page_state(zone, NR_ZONE_WRITE_PENDING)),

			K(zone->present_pages),

			K(zone_managed_pages(zone)),

			K(zone_page_state(zone, NR_MLOCK)),

			K(zone_page_state(zone, NR_BOUNCE)),

			K(free_pcp),

			K(this_cpu_read(zone->per_cpu_pageset->count)),

			K(zone_page_state(zone, NR_FREE_CMA_PAGES)));

		printk("lowmem_reserve[]:");

		for (i = 0; i < MAX_NR_ZONES; i++)

			printk(KERN_CONT " %ld", zone->lowmem_reserve[i]);

		printk(KERN_CONT "\n");

	}



	for_each_populated_zone(zone) {

		unsigned int order;

		unsigned long nr[MAX_ORDER + 1], flags, total = 0;

		unsigned char types[MAX_ORDER + 1];



		if (zone_idx(zone) > max_zone_idx)

			continue;

		if (show_mem_node_skip(filter, zone_to_nid(zone), nodemask))

			continue;

		show_node(zone);

		printk(KERN_CONT "%s: ", zone->name);



		spin_lock_irqsave(&zone->lock, flags);

		for (order = 0; order <= MAX_ORDER; order++) {

			struct free_area *area = &zone->free_area[order];

			int type;



			nr[order] = area->nr_free;

			total += nr[order] << order;



			types[order] = 0;

			for (type = 0; type < MIGRATE_TYPES; type++) {

				if (!free_area_empty(area, type))

					types[order] |= 1 << type;

			}

		}

		spin_unlock_irqrestore(&zone->lock, flags);

		for (order = 0; order <= MAX_ORDER; order++) {

			printk(KERN_CONT "%lu*%lukB ",

			       nr[order], K(1UL) << order);

			if (nr[order])

				show_migration_types(types[order]);

		}

		printk(KERN_CONT "= %lukB\n", K(total));

	}



	for_each_online_node(nid) {

		if (show_mem_node_skip(filter, nid, nodemask))

			continue;

		hugetlb_show_meminfo_node(nid);

	}



	printk("%ld total pagecache pages\n", global_node_page_state(NR_FILE_PAGES));



	show_swap_cache_info();

}



static void zoneref_set_zone(struct zone *zone, struct zoneref *zoneref)

static void zoneref_set_zone(struct zone *zone, struct zoneref *zoneref)

{

{

	zoneref->zone = zone;

	zoneref->zone = zone;

mm/show_mem.c

0 → 100644
+429 −0

File added.

Preview size limit exceeded, changes collapsed.