Merge tag 'for-6.6-rc1-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave...
[platform/kernel/linux-rpi.git] / mm / show_mem.c
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  */
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[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");
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 }