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