[linux.git] / mm / show_mem.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Generic show_mem() implementation
 *
 * Copyright (C) 2008 Johannes Weiner <[email protected]>
 */

#include <linux/blkdev.h>
#include <linux/cma.h>
#include <linux/cpuset.h>
#include <linux/highmem.h>
#include <linux/hugetlb.h>
#include <linux/mm.h>
#include <linux/mmzone.h>
#include <linux/swap.h>
#include <linux/vmstat.h>

#include "internal.h"
#include "swap.h"

atomic_long_t _totalram_pages __read_mostly;
EXPORT_SYMBOL(_totalram_pages);
unsigned long totalreserve_pages __read_mostly;
unsigned long totalcma_pages __read_mostly;

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 reclaimable;
	struct zone *zone;

	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 = global_node_page_state(NR_ACTIVE_FILE) +
		global_node_page_state(NR_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);
	reclaimable -= min(reclaimable / 2, wmark_low);
	available += reclaimable;

	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.
 */
static 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[NR_PAGE_ORDERS], flags, total = 0;
		unsigned char types[NR_PAGE_ORDERS];

		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 < NR_PAGE_ORDERS; 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 < NR_PAGE_ORDERS; 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();
}

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
#ifdef CONFIG_MEM_ALLOC_PROFILING
	{
		struct codetag_bytes tags[10];
		size_t i, nr;

		nr = alloc_tag_top_users(tags, ARRAY_SIZE(tags), false);
		if (nr) {
			pr_notice("Memory allocations:\n");
			for (i = 0; i < nr; i++) {
				struct codetag *ct = tags[i].ct;
				struct alloc_tag *tag = ct_to_alloc_tag(ct);
				struct alloc_tag_counters counter = alloc_tag_read(tag);

				/* Same as alloc_tag_to_text() but w/o intermediate buffer */
				if (ct->modname)
					pr_notice("%12lli %8llu %s:%u [%s] func:%s\n",
						  counter.bytes, counter.calls, ct->filename,
						  ct->lineno, ct->modname, ct->function);
				else
					pr_notice("%12lli %8llu %s:%u func:%s\n",
						  counter.bytes, counter.calls, ct->filename,
						  ct->lineno, ct->function);
			}
		}
	}
#endif
}
Commit	Line	Data
e9aae170 KW	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/*
	3	* Generic show_mem() implementation
	4	*
	5	* Copyright (C) 2008 Johannes Weiner <[email protected]>
	6	*/
	7
	8	#include <linux/blkdev.h>
	9	#include <linux/cma.h>
	10	#include <linux/cpuset.h>
	11	#include <linux/highmem.h>
	12	#include <linux/hugetlb.h>
	13	#include <linux/mm.h>
	14	#include <linux/mmzone.h>
	15	#include <linux/swap.h>
	16	#include <linux/vmstat.h>
	17
	18	#include "internal.h"
	19	#include "swap.h"
	20
	21	atomic_long_t _totalram_pages __read_mostly;
	22	EXPORT_SYMBOL(_totalram_pages);
	23	unsigned long totalreserve_pages __read_mostly;
	24	unsigned long totalcma_pages __read_mostly;
	25
	26	static inline void show_node(struct zone *zone)
	27	{
	28	if (IS_ENABLED(CONFIG_NUMA))
	29	printk("Node %d ", zone_to_nid(zone));
	30	}
	31
	32	long si_mem_available(void)
	33	{
	34	long available;
	35	unsigned long pagecache;
	36	unsigned long wmark_low = 0;
e9aae170 KW	37	unsigned long reclaimable;
e9aae170 KW	38	struct zone *zone;
e9aae170 KW	39
	40	for_each_zone(zone)
	41	wmark_low += low_wmark_pages(zone);
	42
	43	/*
	44	* Estimate the amount of memory available for userspace allocations,
	45	* without causing swapping or OOM.
	46	*/
	47	available = global_zone_page_state(NR_FREE_PAGES) - totalreserve_pages;
	48
	49	/*
	50	* Not all the page cache can be freed, otherwise the system will
	51	* start swapping or thrashing. Assume at least half of the page
	52	* cache, or the low watermark worth of cache, needs to stay.
	53	*/
80e4a765 LS	54	pagecache = global_node_page_state(NR_ACTIVE_FILE) +
80e4a765 LS	55	global_node_page_state(NR_INACTIVE_FILE);
e9aae170 KW	56	pagecache -= min(pagecache / 2, wmark_low);
	57	available += pagecache;
	58
	59	/*
	60	* Part of the reclaimable slab and other kernel memory consists of
	61	* items that are in use, and cannot be freed. Cap this estimate at the
	62	* low watermark.
	63	*/
	64	reclaimable = global_node_page_state_pages(NR_SLAB_RECLAIMABLE_B) +
	65	global_node_page_state(NR_KERNEL_MISC_RECLAIMABLE);
80e4a765 LS	66	reclaimable -= min(reclaimable / 2, wmark_low);
80e4a765 LS	67	available += reclaimable;
e9aae170 KW	68
	69	if (available < 0)
	70	available = 0;
	71	return available;
	72	}
	73	EXPORT_SYMBOL_GPL(si_mem_available);
	74
	75	void si_meminfo(struct sysinfo *val)
	76	{
	77	val->totalram = totalram_pages();
	78	val->sharedram = global_node_page_state(NR_SHMEM);
	79	val->freeram = global_zone_page_state(NR_FREE_PAGES);
	80	val->bufferram = nr_blockdev_pages();
	81	val->totalhigh = totalhigh_pages();
	82	val->freehigh = nr_free_highpages();
	83	val->mem_unit = PAGE_SIZE;
	84	}
	85
	86	EXPORT_SYMBOL(si_meminfo);
	87
	88	#ifdef CONFIG_NUMA
	89	void si_meminfo_node(struct sysinfo *val, int nid)
	90	{
	91	int zone_type; /* needs to be signed */
	92	unsigned long managed_pages = 0;
	93	unsigned long managed_highpages = 0;
	94	unsigned long free_highpages = 0;
	95	pg_data_t *pgdat = NODE_DATA(nid);
	96
	97	for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++)
	98	managed_pages += zone_managed_pages(&pgdat->node_zones[zone_type]);
	99	val->totalram = managed_pages;
	100	val->sharedram = node_page_state(pgdat, NR_SHMEM);
	101	val->freeram = sum_zone_node_page_state(nid, NR_FREE_PAGES);
	102	#ifdef CONFIG_HIGHMEM
	103	for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++) {
	104	struct zone *zone = &pgdat->node_zones[zone_type];
	105
	106	if (is_highmem(zone)) {
	107	managed_highpages += zone_managed_pages(zone);
	108	free_highpages += zone_page_state(zone, NR_FREE_PAGES);
	109	}
	110	}
	111	val->totalhigh = managed_highpages;
	112	val->freehigh = free_highpages;
	113	#else
	114	val->totalhigh = managed_highpages;
	115	val->freehigh = free_highpages;
	116	#endif
	117	val->mem_unit = PAGE_SIZE;
	118	}
	119	#endif
	120
	121	/*
	122	* Determine whether the node should be displayed or not, depending on whether
	123	* SHOW_MEM_FILTER_NODES was passed to show_free_areas().
	124	*/
	125	static bool show_mem_node_skip(unsigned int flags, int nid, nodemask_t *nodemask)
	126	{
	127	if (!(flags & SHOW_MEM_FILTER_NODES))
	128	return false;
	129
	130	/*
	131	* no node mask - aka implicit memory numa policy. Do not bother with
132	* the synchronization - read_mems_allowed_begin - because we do not
133	* have to be precise here.
134	*/
135	if (!nodemask)
136	nodemask = &cpuset_current_mems_allowed;
137
138	return !node_isset(nid, *nodemask);
139	}
140
141	static void show_migration_types(unsigned char type)
142	{
143	static const char types[MIGRATE_TYPES] = {
144	[MIGRATE_UNMOVABLE] = 'U',
145	[MIGRATE_MOVABLE] = 'M',
146	[MIGRATE_RECLAIMABLE] = 'E',
147	[MIGRATE_HIGHATOMIC] = 'H',
148	#ifdef CONFIG_CMA
149	[MIGRATE_CMA] = 'C',
150	#endif
151	#ifdef CONFIG_MEMORY_ISOLATION
152	[MIGRATE_ISOLATE] = 'I',
153	#endif
154	};
155	char tmp[MIGRATE_TYPES + 1];
156	char *p = tmp;
157	int i;
158
159	for (i = 0; i < MIGRATE_TYPES; i++) {
160	if (type & (1 << i))
161	*p++ = types[i];
162	}
163
164	*p = '\0';
165	printk(KERN_CONT "(%s) ", tmp);
166	}
167
168	static bool node_has_managed_zones(pg_data_t *pgdat, int max_zone_idx)
169	{
170	int zone_idx;
171	for (zone_idx = 0; zone_idx <= max_zone_idx; zone_idx++)
172	if (zone_managed_pages(pgdat->node_zones + zone_idx))
173	return true;
174	return false;
175	}
176
177	/*
178	* Show free area list (used inside shift_scroll-lock stuff)
179	* We also calculate the percentage fragmentation. We do this by counting the
180	* memory on each free list with the exception of the first item on the list.
181	*
182	* Bits in @filter:
183	* SHOW_MEM_FILTER_NODES: suppress nodes that are not allowed by current's
184	* cpuset.
185	*/
1279aa06	186	static void show_free_areas(unsigned int filter, nodemask_t *nodemask, int max_zone_idx)
e9aae170 KW	187	{
	188	unsigned long free_pcp = 0;
	189	int cpu, nid;
	190	struct zone *zone;
	191	pg_data_t *pgdat;
	192
	193	for_each_populated_zone(zone) {
	194	if (zone_idx(zone) > max_zone_idx)
	195	continue;
	196	if (show_mem_node_skip(filter, zone_to_nid(zone), nodemask))
	197	continue;
	198
	199	for_each_online_cpu(cpu)
	200	free_pcp += per_cpu_ptr(zone->per_cpu_pageset, cpu)->count;
	201	}
	202
	203	printk("active_anon:%lu inactive_anon:%lu isolated_anon:%lu\n"
	204	" active_file:%lu inactive_file:%lu isolated_file:%lu\n"
	205	" unevictable:%lu dirty:%lu writeback:%lu\n"
	206	" slab_reclaimable:%lu slab_unreclaimable:%lu\n"
	207	" mapped:%lu shmem:%lu pagetables:%lu\n"
	208	" sec_pagetables:%lu bounce:%lu\n"
	209	" kernel_misc_reclaimable:%lu\n"
	210	" free:%lu free_pcp:%lu free_cma:%lu\n",
	211	global_node_page_state(NR_ACTIVE_ANON),
	212	global_node_page_state(NR_INACTIVE_ANON),
	213	global_node_page_state(NR_ISOLATED_ANON),
	214	global_node_page_state(NR_ACTIVE_FILE),
	215	global_node_page_state(NR_INACTIVE_FILE),
	216	global_node_page_state(NR_ISOLATED_FILE),
	217	global_node_page_state(NR_UNEVICTABLE),
	218	global_node_page_state(NR_FILE_DIRTY),
	219	global_node_page_state(NR_WRITEBACK),
	220	global_node_page_state_pages(NR_SLAB_RECLAIMABLE_B),
	221	global_node_page_state_pages(NR_SLAB_UNRECLAIMABLE_B),
	222	global_node_page_state(NR_FILE_MAPPED),
	223	global_node_page_state(NR_SHMEM),
	224	global_node_page_state(NR_PAGETABLE),
	225	global_node_page_state(NR_SECONDARY_PAGETABLE),
	226	global_zone_page_state(NR_BOUNCE),
	227	global_node_page_state(NR_KERNEL_MISC_RECLAIMABLE),
	228	global_zone_page_state(NR_FREE_PAGES),
	229	free_pcp,
	230	global_zone_page_state(NR_FREE_CMA_PAGES));
	231
	232	for_each_online_pgdat(pgdat) {
	233	if (show_mem_node_skip(filter, pgdat->node_id, nodemask))
	234	continue;
	235	if (!node_has_managed_zones(pgdat, max_zone_idx))
	236	continue;
	237
	238	printk("Node %d"
	239	" active_anon:%lukB"
	240	" inactive_anon:%lukB"
	241	" active_file:%lukB"
	242	" inactive_file:%lukB"
	243	" unevictable:%lukB"
	244	" isolated(anon):%lukB"
	245	" isolated(file):%lukB"
	246	" mapped:%lukB"
	247	" dirty:%lukB"
	248	" writeback:%lukB"
	249	" shmem:%lukB"
	250	#ifdef CONFIG_TRANSPARENT_HUGEPAGE
8dbbc493 HD	251	" shmem_thp:%lukB"
	252	" shmem_pmdmapped:%lukB"
	253	" anon_thp:%lukB"
e9aae170 KW	254	#endif
	255	" writeback_tmp:%lukB"
	256	" kernel_stack:%lukB"
	257	#ifdef CONFIG_SHADOW_CALL_STACK
	258	" shadow_call_stack:%lukB"
	259	#endif
	260	" pagetables:%lukB"
	261	" sec_pagetables:%lukB"
	262	" all_unreclaimable? %s"
	263	"\n",
	264	pgdat->node_id,
	265	K(node_page_state(pgdat, NR_ACTIVE_ANON)),
	266	K(node_page_state(pgdat, NR_INACTIVE_ANON)),
	267	K(node_page_state(pgdat, NR_ACTIVE_FILE)),
	268	K(node_page_state(pgdat, NR_INACTIVE_FILE)),
	269	K(node_page_state(pgdat, NR_UNEVICTABLE)),
	270	K(node_page_state(pgdat, NR_ISOLATED_ANON)),
	271	K(node_page_state(pgdat, NR_ISOLATED_FILE)),
	272	K(node_page_state(pgdat, NR_FILE_MAPPED)),
	273	K(node_page_state(pgdat, NR_FILE_DIRTY)),
	274	K(node_page_state(pgdat, NR_WRITEBACK)),
	275	K(node_page_state(pgdat, NR_SHMEM)),
	276	#ifdef CONFIG_TRANSPARENT_HUGEPAGE
	277	K(node_page_state(pgdat, NR_SHMEM_THPS)),
	278	K(node_page_state(pgdat, NR_SHMEM_PMDMAPPED)),
	279	K(node_page_state(pgdat, NR_ANON_THPS)),
	280	#endif
	281	K(node_page_state(pgdat, NR_WRITEBACK_TEMP)),
	282	node_page_state(pgdat, NR_KERNEL_STACK_KB),
	283	#ifdef CONFIG_SHADOW_CALL_STACK
	284	node_page_state(pgdat, NR_KERNEL_SCS_KB),
	285	#endif
	286	K(node_page_state(pgdat, NR_PAGETABLE)),
	287	K(node_page_state(pgdat, NR_SECONDARY_PAGETABLE)),
	288	pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES ?
	289	"yes" : "no");
	290	}
	291
	292	for_each_populated_zone(zone) {
	293	int i;
	294
	295	if (zone_idx(zone) > max_zone_idx)
	296	continue;
	297	if (show_mem_node_skip(filter, zone_to_nid(zone), nodemask))
	298	continue;
	299
	300	free_pcp = 0;
	301	for_each_online_cpu(cpu)
	302	free_pcp += per_cpu_ptr(zone->per_cpu_pageset, cpu)->count;
	303
	304	show_node(zone);
	305	printk(KERN_CONT
	306	"%s"
	307	" free:%lukB"
	308	" boost:%lukB"
	309	" min:%lukB"
	310	" low:%lukB"
	311	" high:%lukB"
	312	" reserved_highatomic:%luKB"
	313	" active_anon:%lukB"
	314	" inactive_anon:%lukB"
	315	" active_file:%lukB"
	316	" inactive_file:%lukB"
	317	" unevictable:%lukB"
318	" writepending:%lukB"
319	" present:%lukB"
320	" managed:%lukB"
321	" mlocked:%lukB"
322	" bounce:%lukB"
323	" free_pcp:%lukB"
324	" local_pcp:%ukB"
325	" free_cma:%lukB"
326	"\n",
327	zone->name,
328	K(zone_page_state(zone, NR_FREE_PAGES)),
329	K(zone->watermark_boost),
330	K(min_wmark_pages(zone)),
331	K(low_wmark_pages(zone)),
332	K(high_wmark_pages(zone)),
333	K(zone->nr_reserved_highatomic),
334	K(zone_page_state(zone, NR_ZONE_ACTIVE_ANON)),
335	K(zone_page_state(zone, NR_ZONE_INACTIVE_ANON)),
336	K(zone_page_state(zone, NR_ZONE_ACTIVE_FILE)),
337	K(zone_page_state(zone, NR_ZONE_INACTIVE_FILE)),
338	K(zone_page_state(zone, NR_ZONE_UNEVICTABLE)),
339	K(zone_page_state(zone, NR_ZONE_WRITE_PENDING)),
340	K(zone->present_pages),
341	K(zone_managed_pages(zone)),
342	K(zone_page_state(zone, NR_MLOCK)),
343	K(zone_page_state(zone, NR_BOUNCE)),
344	K(free_pcp),
345	K(this_cpu_read(zone->per_cpu_pageset->count)),
346	K(zone_page_state(zone, NR_FREE_CMA_PAGES)));
347	printk("lowmem_reserve[]:");
348	for (i = 0; i < MAX_NR_ZONES; i++)
349	printk(KERN_CONT " %ld", zone->lowmem_reserve[i]);
350	printk(KERN_CONT "\n");
351	}
352
353	for_each_populated_zone(zone) {
354	unsigned int order;
fd377218 KS	355	unsigned long nr[NR_PAGE_ORDERS], flags, total = 0;
fd377218 KS	356	unsigned char types[NR_PAGE_ORDERS];
e9aae170 KW	357
	358	if (zone_idx(zone) > max_zone_idx)
	359	continue;
	360	if (show_mem_node_skip(filter, zone_to_nid(zone), nodemask))
	361	continue;
	362	show_node(zone);
	363	printk(KERN_CONT "%s: ", zone->name);
	364
	365	spin_lock_irqsave(&zone->lock, flags);
fd377218	366	for (order = 0; order < NR_PAGE_ORDERS; order++) {
e9aae170 KW	367	struct free_area *area = &zone->free_area[order];
	368	int type;
	369
	370	nr[order] = area->nr_free;
	371	total += nr[order] << order;
	372
	373	types[order] = 0;
	374	for (type = 0; type < MIGRATE_TYPES; type++) {
	375	if (!free_area_empty(area, type))
	376	types[order] \|= 1 << type;
	377	}
	378	}
	379	spin_unlock_irqrestore(&zone->lock, flags);
fd377218	380	for (order = 0; order < NR_PAGE_ORDERS; order++) {
e9aae170 KW	381	printk(KERN_CONT "%lu*%lukB ",
	382	nr[order], K(1UL) << order);
	383	if (nr[order])
	384	show_migration_types(types[order]);
	385	}
	386	printk(KERN_CONT "= %lukB\n", K(total));
	387	}
	388
	389	for_each_online_node(nid) {
	390	if (show_mem_node_skip(filter, nid, nodemask))
	391	continue;
	392	hugetlb_show_meminfo_node(nid);
	393	}
	394
	395	printk("%ld total pagecache pages\n", global_node_page_state(NR_FILE_PAGES));
	396
	397	show_swap_cache_info();
	398	}
	399
	400	void __show_mem(unsigned int filter, nodemask_t *nodemask, int max_zone_idx)
	401	{
	402	unsigned long total = 0, reserved = 0, highmem = 0;
	403	struct zone *zone;
	404
	405	printk("Mem-Info:\n");
1279aa06	406	show_free_areas(filter, nodemask, max_zone_idx);
e9aae170 KW	407
	408	for_each_populated_zone(zone) {
	409
	410	total += zone->present_pages;
	411	reserved += zone->present_pages - zone_managed_pages(zone);
	412
	413	if (is_highmem(zone))
	414	highmem += zone->present_pages;
	415	}
	416
	417	printk("%lu pages RAM\n", total);
	418	printk("%lu pages HighMem/MovableOnly\n", highmem);
	419	printk("%lu pages reserved\n", reserved);
	420	#ifdef CONFIG_CMA
	421	printk("%lu pages cma reserved\n", totalcma_pages);
	422	#endif
	423	#ifdef CONFIG_MEMORY_FAILURE
	424	printk("%lu pages hwpoisoned\n", atomic_long_read(&num_poisoned_pages));
	425	#endif
1438d349 SB	426	#ifdef CONFIG_MEM_ALLOC_PROFILING
	427	{
	428	struct codetag_bytes tags[10];
	429	size_t i, nr;
	430
	431	nr = alloc_tag_top_users(tags, ARRAY_SIZE(tags), false);
	432	if (nr) {
	433	pr_notice("Memory allocations:\n");
	434	for (i = 0; i < nr; i++) {
	435	struct codetag *ct = tags[i].ct;
	436	struct alloc_tag *tag = ct_to_alloc_tag(ct);
	437	struct alloc_tag_counters counter = alloc_tag_read(tag);
	438
	439	/* Same as alloc_tag_to_text() but w/o intermediate buffer */
	440	if (ct->modname)
	441	pr_notice("%12lli %8llu %s:%u [%s] func:%s\n",
	442	counter.bytes, counter.calls, ct->filename,
	443	ct->lineno, ct->modname, ct->function);
	444	else
	445	pr_notice("%12lli %8llu %s:%u func:%s\n",
	446	counter.bytes, counter.calls, ct->filename,
	447	ct->lineno, ct->function);
	448	}
	449	}
	450	}
	451	#endif
e9aae170	452	}