4 * Manages VM statistics
5 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
8 #include <linux/config.h>
12 * Accumulate the page_state information across all CPUs.
13 * The result is unavoidably approximate - it can change
14 * during and after execution of this function.
16 DEFINE_PER_CPU(struct page_state, page_states) = {0};
18 atomic_t nr_pagecache = ATOMIC_INIT(0);
19 EXPORT_SYMBOL(nr_pagecache);
21 DEFINE_PER_CPU(long, nr_pagecache_local) = 0;
24 static void __get_page_state(struct page_state *ret, int nr, cpumask_t *cpumask)
28 memset(ret, 0, nr * sizeof(unsigned long));
29 cpus_and(*cpumask, *cpumask, cpu_online_map);
31 for_each_cpu_mask(cpu, *cpumask) {
37 in = (unsigned long *)&per_cpu(page_states, cpu);
39 next_cpu = next_cpu(cpu, *cpumask);
40 if (likely(next_cpu < NR_CPUS))
41 prefetch(&per_cpu(page_states, next_cpu));
43 out = (unsigned long *)ret;
44 for (off = 0; off < nr; off++)
49 void get_page_state_node(struct page_state *ret, int node)
52 cpumask_t mask = node_to_cpumask(node);
54 nr = offsetof(struct page_state, GET_PAGE_STATE_LAST);
55 nr /= sizeof(unsigned long);
57 __get_page_state(ret, nr+1, &mask);
60 void get_page_state(struct page_state *ret)
63 cpumask_t mask = CPU_MASK_ALL;
65 nr = offsetof(struct page_state, GET_PAGE_STATE_LAST);
66 nr /= sizeof(unsigned long);
68 __get_page_state(ret, nr + 1, &mask);
71 void get_full_page_state(struct page_state *ret)
73 cpumask_t mask = CPU_MASK_ALL;
75 __get_page_state(ret, sizeof(*ret) / sizeof(unsigned long), &mask);
78 unsigned long read_page_state_offset(unsigned long offset)
80 unsigned long ret = 0;
83 for_each_online_cpu(cpu) {
86 in = (unsigned long)&per_cpu(page_states, cpu) + offset;
87 ret += *((unsigned long *)in);
92 void __mod_page_state_offset(unsigned long offset, unsigned long delta)
96 ptr = &__get_cpu_var(page_states);
97 *(unsigned long *)(ptr + offset) += delta;
99 EXPORT_SYMBOL(__mod_page_state_offset);
101 void mod_page_state_offset(unsigned long offset, unsigned long delta)
106 local_irq_save(flags);
107 ptr = &__get_cpu_var(page_states);
108 *(unsigned long *)(ptr + offset) += delta;
109 local_irq_restore(flags);
111 EXPORT_SYMBOL(mod_page_state_offset);
113 void __get_zone_counts(unsigned long *active, unsigned long *inactive,
114 unsigned long *free, struct pglist_data *pgdat)
116 struct zone *zones = pgdat->node_zones;
122 for (i = 0; i < MAX_NR_ZONES; i++) {
123 *active += zones[i].nr_active;
124 *inactive += zones[i].nr_inactive;
125 *free += zones[i].free_pages;
129 void get_zone_counts(unsigned long *active,
130 unsigned long *inactive, unsigned long *free)
132 struct pglist_data *pgdat;
137 for_each_online_pgdat(pgdat) {
138 unsigned long l, m, n;
139 __get_zone_counts(&l, &m, &n, pgdat);
146 #ifdef CONFIG_PROC_FS
148 #include <linux/seq_file.h>
150 static void *frag_start(struct seq_file *m, loff_t *pos)
154 for (pgdat = first_online_pgdat();
156 pgdat = next_online_pgdat(pgdat))
162 static void *frag_next(struct seq_file *m, void *arg, loff_t *pos)
164 pg_data_t *pgdat = (pg_data_t *)arg;
167 return next_online_pgdat(pgdat);
170 static void frag_stop(struct seq_file *m, void *arg)
175 * This walks the free areas for each zone.
177 static int frag_show(struct seq_file *m, void *arg)
179 pg_data_t *pgdat = (pg_data_t *)arg;
181 struct zone *node_zones = pgdat->node_zones;
185 for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) {
186 if (!populated_zone(zone))
189 spin_lock_irqsave(&zone->lock, flags);
190 seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name);
191 for (order = 0; order < MAX_ORDER; ++order)
192 seq_printf(m, "%6lu ", zone->free_area[order].nr_free);
193 spin_unlock_irqrestore(&zone->lock, flags);
199 struct seq_operations fragmentation_op = {
206 static char *vmstat_text[] = {
210 "nr_page_table_pages",
241 "pgscan_kswapd_high",
242 "pgscan_kswapd_normal",
243 "pgscan_kswapd_dma32",
246 "pgscan_direct_high",
247 "pgscan_direct_normal",
248 "pgscan_direct_dma32",
263 * Output information about zones in @pgdat.
265 static int zoneinfo_show(struct seq_file *m, void *arg)
267 pg_data_t *pgdat = arg;
269 struct zone *node_zones = pgdat->node_zones;
272 for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; zone++) {
275 if (!populated_zone(zone))
278 spin_lock_irqsave(&zone->lock, flags);
279 seq_printf(m, "Node %d, zone %8s", pgdat->node_id, zone->name);
287 "\n scanned %lu (a: %lu i: %lu)"
297 zone->nr_scan_active, zone->nr_scan_inactive,
299 zone->present_pages);
301 "\n protection: (%lu",
302 zone->lowmem_reserve[0]);
303 for (i = 1; i < ARRAY_SIZE(zone->lowmem_reserve); i++)
304 seq_printf(m, ", %lu", zone->lowmem_reserve[i]);
308 for_each_online_cpu(i) {
309 struct per_cpu_pageset *pageset;
312 pageset = zone_pcp(zone, i);
313 for (j = 0; j < ARRAY_SIZE(pageset->pcp); j++) {
314 if (pageset->pcp[j].count)
317 if (j == ARRAY_SIZE(pageset->pcp))
319 for (j = 0; j < ARRAY_SIZE(pageset->pcp); j++) {
326 pageset->pcp[j].count,
327 pageset->pcp[j].high,
328 pageset->pcp[j].batch);
334 "\n numa_foreign: %lu"
335 "\n interleave_hit: %lu"
337 "\n other_node: %lu",
340 pageset->numa_foreign,
341 pageset->interleave_hit,
343 pageset->other_node);
347 "\n all_unreclaimable: %u"
348 "\n prev_priority: %i"
349 "\n temp_priority: %i"
351 zone->all_unreclaimable,
354 zone->zone_start_pfn);
355 spin_unlock_irqrestore(&zone->lock, flags);
361 struct seq_operations zoneinfo_op = {
362 .start = frag_start, /* iterate over all zones. The same as in
366 .show = zoneinfo_show,
369 static void *vmstat_start(struct seq_file *m, loff_t *pos)
371 struct page_state *ps;
373 if (*pos >= ARRAY_SIZE(vmstat_text))
376 ps = kmalloc(sizeof(*ps), GFP_KERNEL);
379 return ERR_PTR(-ENOMEM);
380 get_full_page_state(ps);
381 ps->pgpgin /= 2; /* sectors -> kbytes */
383 return (unsigned long *)ps + *pos;
386 static void *vmstat_next(struct seq_file *m, void *arg, loff_t *pos)
389 if (*pos >= ARRAY_SIZE(vmstat_text))
391 return (unsigned long *)m->private + *pos;
394 static int vmstat_show(struct seq_file *m, void *arg)
396 unsigned long *l = arg;
397 unsigned long off = l - (unsigned long *)m->private;
399 seq_printf(m, "%s %lu\n", vmstat_text[off], *l);
403 static void vmstat_stop(struct seq_file *m, void *arg)
409 struct seq_operations vmstat_op = {
410 .start = vmstat_start,
416 #endif /* CONFIG_PROC_FS */