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 <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 | ||
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; | |
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 | ||
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 | |
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 | */ | |
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 | ||
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 | ||
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 | */ | |
1279aa06 | 189 | static void show_free_areas(unsigned int filter, nodemask_t *nodemask, int max_zone_idx) |
e9aae170 KW |
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 | |
8dbbc493 HD |
254 | " shmem_thp:%lukB" |
255 | " shmem_pmdmapped:%lukB" | |
256 | " anon_thp:%lukB" | |
e9aae170 KW |
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[MAX_ORDER + 1], flags, total = 0; | |
359 | unsigned char types[MAX_ORDER + 1]; | |
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 <= MAX_ORDER; 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 <= MAX_ORDER; 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 | ||
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"); | |
1279aa06 | 409 | show_free_areas(filter, nodemask, max_zone_idx); |
e9aae170 KW |
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 | } |