blob: 45b124e012f5fe8c7c8274dfd3f8f0861ce58aaa [file] [log] [blame]
Christoph Lameterf6ac2352006-06-30 01:55:32 -07001/*
2 * linux/mm/vmstat.c
3 *
4 * Manages VM statistics
5 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
Christoph Lameter2244b952006-06-30 01:55:33 -07006 *
7 * zoned VM statistics
8 * Copyright (C) 2006 Silicon Graphics, Inc.,
9 * Christoph Lameter <christoph@lameter.com>
Christoph Lameterf6ac2352006-06-30 01:55:32 -070010 */
11
Christoph Lameterf6ac2352006-06-30 01:55:32 -070012#include <linux/mm.h>
Christoph Lameter2244b952006-06-30 01:55:33 -070013#include <linux/module.h>
Christoph Lameterdf9ecab2006-08-31 21:27:35 -070014#include <linux/cpu.h>
Christoph Lameterf6ac2352006-06-30 01:55:32 -070015
Christoph Lameterf6ac2352006-06-30 01:55:32 -070016void __get_zone_counts(unsigned long *active, unsigned long *inactive,
17 unsigned long *free, struct pglist_data *pgdat)
18{
19 struct zone *zones = pgdat->node_zones;
20 int i;
21
22 *active = 0;
23 *inactive = 0;
24 *free = 0;
25 for (i = 0; i < MAX_NR_ZONES; i++) {
26 *active += zones[i].nr_active;
27 *inactive += zones[i].nr_inactive;
28 *free += zones[i].free_pages;
29 }
30}
31
32void get_zone_counts(unsigned long *active,
33 unsigned long *inactive, unsigned long *free)
34{
35 struct pglist_data *pgdat;
36
37 *active = 0;
38 *inactive = 0;
39 *free = 0;
40 for_each_online_pgdat(pgdat) {
41 unsigned long l, m, n;
42 __get_zone_counts(&l, &m, &n, pgdat);
43 *active += l;
44 *inactive += m;
45 *free += n;
46 }
47}
48
Christoph Lameterf8891e52006-06-30 01:55:45 -070049#ifdef CONFIG_VM_EVENT_COUNTERS
50DEFINE_PER_CPU(struct vm_event_state, vm_event_states) = {{0}};
51EXPORT_PER_CPU_SYMBOL(vm_event_states);
52
53static void sum_vm_events(unsigned long *ret, cpumask_t *cpumask)
54{
55 int cpu = 0;
56 int i;
57
58 memset(ret, 0, NR_VM_EVENT_ITEMS * sizeof(unsigned long));
59
60 cpu = first_cpu(*cpumask);
61 while (cpu < NR_CPUS) {
62 struct vm_event_state *this = &per_cpu(vm_event_states, cpu);
63
64 cpu = next_cpu(cpu, *cpumask);
65
66 if (cpu < NR_CPUS)
67 prefetch(&per_cpu(vm_event_states, cpu));
68
69
70 for (i = 0; i < NR_VM_EVENT_ITEMS; i++)
71 ret[i] += this->event[i];
72 }
73}
74
75/*
76 * Accumulate the vm event counters across all CPUs.
77 * The result is unavoidably approximate - it can change
78 * during and after execution of this function.
79*/
80void all_vm_events(unsigned long *ret)
81{
82 sum_vm_events(ret, &cpu_online_map);
83}
Heiko Carstens32dd66f2006-07-10 04:44:31 -070084EXPORT_SYMBOL_GPL(all_vm_events);
Christoph Lameterf8891e52006-06-30 01:55:45 -070085
86#ifdef CONFIG_HOTPLUG
87/*
88 * Fold the foreign cpu events into our own.
89 *
90 * This is adding to the events on one processor
91 * but keeps the global counts constant.
92 */
93void vm_events_fold_cpu(int cpu)
94{
95 struct vm_event_state *fold_state = &per_cpu(vm_event_states, cpu);
96 int i;
97
98 for (i = 0; i < NR_VM_EVENT_ITEMS; i++) {
99 count_vm_events(i, fold_state->event[i]);
100 fold_state->event[i] = 0;
101 }
102}
103#endif /* CONFIG_HOTPLUG */
104
105#endif /* CONFIG_VM_EVENT_COUNTERS */
106
Christoph Lameter2244b952006-06-30 01:55:33 -0700107/*
108 * Manage combined zone based / global counters
109 *
110 * vm_stat contains the global counters
111 */
112atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
113EXPORT_SYMBOL(vm_stat);
114
115#ifdef CONFIG_SMP
116
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700117static int calculate_threshold(struct zone *zone)
118{
119 int threshold;
120 int mem; /* memory in 128 MB units */
121
122 /*
123 * The threshold scales with the number of processors and the amount
124 * of memory per zone. More memory means that we can defer updates for
125 * longer, more processors could lead to more contention.
126 * fls() is used to have a cheap way of logarithmic scaling.
127 *
128 * Some sample thresholds:
129 *
130 * Threshold Processors (fls) Zonesize fls(mem+1)
131 * ------------------------------------------------------------------
132 * 8 1 1 0.9-1 GB 4
133 * 16 2 2 0.9-1 GB 4
134 * 20 2 2 1-2 GB 5
135 * 24 2 2 2-4 GB 6
136 * 28 2 2 4-8 GB 7
137 * 32 2 2 8-16 GB 8
138 * 4 2 2 <128M 1
139 * 30 4 3 2-4 GB 5
140 * 48 4 3 8-16 GB 8
141 * 32 8 4 1-2 GB 4
142 * 32 8 4 0.9-1GB 4
143 * 10 16 5 <128M 1
144 * 40 16 5 900M 4
145 * 70 64 7 2-4 GB 5
146 * 84 64 7 4-8 GB 6
147 * 108 512 9 4-8 GB 6
148 * 125 1024 10 8-16 GB 8
149 * 125 1024 10 16-32 GB 9
150 */
151
152 mem = zone->present_pages >> (27 - PAGE_SHIFT);
153
154 threshold = 2 * fls(num_online_cpus()) * (1 + fls(mem));
155
156 /*
157 * Maximum threshold is 125
158 */
159 threshold = min(125, threshold);
160
161 return threshold;
162}
Christoph Lameter2244b952006-06-30 01:55:33 -0700163
164/*
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700165 * Refresh the thresholds for each zone.
Christoph Lameter2244b952006-06-30 01:55:33 -0700166 */
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700167static void refresh_zone_stat_thresholds(void)
Christoph Lameter2244b952006-06-30 01:55:33 -0700168{
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700169 struct zone *zone;
170 int cpu;
171 int threshold;
172
173 for_each_zone(zone) {
174
175 if (!zone->present_pages)
176 continue;
177
178 threshold = calculate_threshold(zone);
179
180 for_each_online_cpu(cpu)
181 zone_pcp(zone, cpu)->stat_threshold = threshold;
182 }
Christoph Lameter2244b952006-06-30 01:55:33 -0700183}
184
185/*
186 * For use when we know that interrupts are disabled.
187 */
188void __mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
189 int delta)
190{
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700191 struct per_cpu_pageset *pcp = zone_pcp(zone, smp_processor_id());
192 s8 *p = pcp->vm_stat_diff + item;
Christoph Lameter2244b952006-06-30 01:55:33 -0700193 long x;
194
Christoph Lameter2244b952006-06-30 01:55:33 -0700195 x = delta + *p;
196
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700197 if (unlikely(x > pcp->stat_threshold || x < -pcp->stat_threshold)) {
Christoph Lameter2244b952006-06-30 01:55:33 -0700198 zone_page_state_add(x, zone, item);
199 x = 0;
200 }
Christoph Lameter2244b952006-06-30 01:55:33 -0700201 *p = x;
202}
203EXPORT_SYMBOL(__mod_zone_page_state);
204
205/*
206 * For an unknown interrupt state
207 */
208void mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
209 int delta)
210{
211 unsigned long flags;
212
213 local_irq_save(flags);
214 __mod_zone_page_state(zone, item, delta);
215 local_irq_restore(flags);
216}
217EXPORT_SYMBOL(mod_zone_page_state);
218
219/*
220 * Optimized increment and decrement functions.
221 *
222 * These are only for a single page and therefore can take a struct page *
223 * argument instead of struct zone *. This allows the inclusion of the code
224 * generated for page_zone(page) into the optimized functions.
225 *
226 * No overflow check is necessary and therefore the differential can be
227 * incremented or decremented in place which may allow the compilers to
228 * generate better code.
Christoph Lameter2244b952006-06-30 01:55:33 -0700229 * The increment or decrement is known and therefore one boundary check can
230 * be omitted.
231 *
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700232 * NOTE: These functions are very performance sensitive. Change only
233 * with care.
234 *
Christoph Lameter2244b952006-06-30 01:55:33 -0700235 * Some processors have inc/dec instructions that are atomic vs an interrupt.
236 * However, the code must first determine the differential location in a zone
237 * based on the processor number and then inc/dec the counter. There is no
238 * guarantee without disabling preemption that the processor will not change
239 * in between and therefore the atomicity vs. interrupt cannot be exploited
240 * in a useful way here.
241 */
Christoph Lameterca889e62006-06-30 01:55:44 -0700242static void __inc_zone_state(struct zone *zone, enum zone_stat_item item)
Christoph Lameter2244b952006-06-30 01:55:33 -0700243{
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700244 struct per_cpu_pageset *pcp = zone_pcp(zone, smp_processor_id());
245 s8 *p = pcp->vm_stat_diff + item;
Christoph Lameter2244b952006-06-30 01:55:33 -0700246
247 (*p)++;
248
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700249 if (unlikely(*p > pcp->stat_threshold)) {
250 int overstep = pcp->stat_threshold / 2;
251
252 zone_page_state_add(*p + overstep, zone, item);
253 *p = -overstep;
Christoph Lameter2244b952006-06-30 01:55:33 -0700254 }
255}
Christoph Lameterca889e62006-06-30 01:55:44 -0700256
257void __inc_zone_page_state(struct page *page, enum zone_stat_item item)
258{
259 __inc_zone_state(page_zone(page), item);
260}
Christoph Lameter2244b952006-06-30 01:55:33 -0700261EXPORT_SYMBOL(__inc_zone_page_state);
262
263void __dec_zone_page_state(struct page *page, enum zone_stat_item item)
264{
265 struct zone *zone = page_zone(page);
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700266 struct per_cpu_pageset *pcp = zone_pcp(zone, smp_processor_id());
267 s8 *p = pcp->vm_stat_diff + item;
Christoph Lameter2244b952006-06-30 01:55:33 -0700268
269 (*p)--;
270
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700271 if (unlikely(*p < - pcp->stat_threshold)) {
272 int overstep = pcp->stat_threshold / 2;
273
274 zone_page_state_add(*p - overstep, zone, item);
275 *p = overstep;
Christoph Lameter2244b952006-06-30 01:55:33 -0700276 }
277}
278EXPORT_SYMBOL(__dec_zone_page_state);
279
Christoph Lameterca889e62006-06-30 01:55:44 -0700280void inc_zone_state(struct zone *zone, enum zone_stat_item item)
281{
282 unsigned long flags;
283
284 local_irq_save(flags);
285 __inc_zone_state(zone, item);
286 local_irq_restore(flags);
287}
288
Christoph Lameter2244b952006-06-30 01:55:33 -0700289void inc_zone_page_state(struct page *page, enum zone_stat_item item)
290{
291 unsigned long flags;
292 struct zone *zone;
Christoph Lameter2244b952006-06-30 01:55:33 -0700293
294 zone = page_zone(page);
295 local_irq_save(flags);
Christoph Lameterca889e62006-06-30 01:55:44 -0700296 __inc_zone_state(zone, item);
Christoph Lameter2244b952006-06-30 01:55:33 -0700297 local_irq_restore(flags);
298}
299EXPORT_SYMBOL(inc_zone_page_state);
300
301void dec_zone_page_state(struct page *page, enum zone_stat_item item)
302{
303 unsigned long flags;
Christoph Lameter2244b952006-06-30 01:55:33 -0700304
Christoph Lameter2244b952006-06-30 01:55:33 -0700305 local_irq_save(flags);
Christoph Lametera302eb42006-08-31 21:27:34 -0700306 __dec_zone_page_state(page, item);
Christoph Lameter2244b952006-06-30 01:55:33 -0700307 local_irq_restore(flags);
308}
309EXPORT_SYMBOL(dec_zone_page_state);
310
311/*
312 * Update the zone counters for one cpu.
313 */
314void refresh_cpu_vm_stats(int cpu)
315{
316 struct zone *zone;
317 int i;
318 unsigned long flags;
319
320 for_each_zone(zone) {
321 struct per_cpu_pageset *pcp;
322
Christoph Lameter39bbcb82006-09-25 23:31:49 -0700323 if (!populated_zone(zone))
324 continue;
325
Christoph Lameter2244b952006-06-30 01:55:33 -0700326 pcp = zone_pcp(zone, cpu);
327
328 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
329 if (pcp->vm_stat_diff[i]) {
330 local_irq_save(flags);
331 zone_page_state_add(pcp->vm_stat_diff[i],
332 zone, i);
333 pcp->vm_stat_diff[i] = 0;
334 local_irq_restore(flags);
335 }
336 }
337}
338
339static void __refresh_cpu_vm_stats(void *dummy)
340{
341 refresh_cpu_vm_stats(smp_processor_id());
342}
343
344/*
345 * Consolidate all counters.
346 *
347 * Note that the result is less inaccurate but still inaccurate
348 * if concurrent processes are allowed to run.
349 */
350void refresh_vm_stats(void)
351{
352 on_each_cpu(__refresh_cpu_vm_stats, NULL, 0, 1);
353}
354EXPORT_SYMBOL(refresh_vm_stats);
355
356#endif
357
Christoph Lameterca889e62006-06-30 01:55:44 -0700358#ifdef CONFIG_NUMA
359/*
360 * zonelist = the list of zones passed to the allocator
361 * z = the zone from which the allocation occurred.
362 *
363 * Must be called with interrupts disabled.
364 */
365void zone_statistics(struct zonelist *zonelist, struct zone *z)
366{
367 if (z->zone_pgdat == zonelist->zones[0]->zone_pgdat) {
368 __inc_zone_state(z, NUMA_HIT);
369 } else {
370 __inc_zone_state(z, NUMA_MISS);
371 __inc_zone_state(zonelist->zones[0], NUMA_FOREIGN);
372 }
Christoph Lameter5d292342006-09-27 01:50:10 -0700373 if (z->node == numa_node_id())
Christoph Lameterca889e62006-06-30 01:55:44 -0700374 __inc_zone_state(z, NUMA_LOCAL);
375 else
376 __inc_zone_state(z, NUMA_OTHER);
377}
378#endif
379
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700380#ifdef CONFIG_PROC_FS
381
382#include <linux/seq_file.h>
383
384static void *frag_start(struct seq_file *m, loff_t *pos)
385{
386 pg_data_t *pgdat;
387 loff_t node = *pos;
388 for (pgdat = first_online_pgdat();
389 pgdat && node;
390 pgdat = next_online_pgdat(pgdat))
391 --node;
392
393 return pgdat;
394}
395
396static void *frag_next(struct seq_file *m, void *arg, loff_t *pos)
397{
398 pg_data_t *pgdat = (pg_data_t *)arg;
399
400 (*pos)++;
401 return next_online_pgdat(pgdat);
402}
403
404static void frag_stop(struct seq_file *m, void *arg)
405{
406}
407
408/*
409 * This walks the free areas for each zone.
410 */
411static int frag_show(struct seq_file *m, void *arg)
412{
413 pg_data_t *pgdat = (pg_data_t *)arg;
414 struct zone *zone;
415 struct zone *node_zones = pgdat->node_zones;
416 unsigned long flags;
417 int order;
418
419 for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) {
420 if (!populated_zone(zone))
421 continue;
422
423 spin_lock_irqsave(&zone->lock, flags);
424 seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name);
425 for (order = 0; order < MAX_ORDER; ++order)
426 seq_printf(m, "%6lu ", zone->free_area[order].nr_free);
427 spin_unlock_irqrestore(&zone->lock, flags);
428 seq_putc(m, '\n');
429 }
430 return 0;
431}
432
433struct seq_operations fragmentation_op = {
434 .start = frag_start,
435 .next = frag_next,
436 .stop = frag_stop,
437 .show = frag_show,
438};
439
Christoph Lameter27bf71c2006-09-25 23:31:15 -0700440#ifdef CONFIG_ZONE_DMA32
441#define TEXT_FOR_DMA32(xx) xx "_dma32",
442#else
443#define TEXT_FOR_DMA32(xx)
444#endif
445
446#ifdef CONFIG_HIGHMEM
447#define TEXT_FOR_HIGHMEM(xx) xx "_high",
448#else
449#define TEXT_FOR_HIGHMEM(xx)
450#endif
451
452#define TEXTS_FOR_ZONES(xx) xx "_dma", TEXT_FOR_DMA32(xx) xx "_normal", \
453 TEXT_FOR_HIGHMEM(xx)
454
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700455static char *vmstat_text[] = {
Christoph Lameter2244b952006-06-30 01:55:33 -0700456 /* Zoned VM counters */
Christoph Lameterf3dbd342006-06-30 01:55:36 -0700457 "nr_anon_pages",
Christoph Lameter65ba55f2006-06-30 01:55:34 -0700458 "nr_mapped",
Christoph Lameter347ce432006-06-30 01:55:35 -0700459 "nr_file_pages",
Christoph Lameter972d1a72006-09-25 23:31:51 -0700460 "nr_slab_reclaimable",
461 "nr_slab_unreclaimable",
Christoph Lameterdf849a12006-06-30 01:55:38 -0700462 "nr_page_table_pages",
Christoph Lameterb1e7a8f2006-06-30 01:55:39 -0700463 "nr_dirty",
Christoph Lameterce866b32006-06-30 01:55:40 -0700464 "nr_writeback",
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700465 "nr_unstable",
Christoph Lameterd2c5e302006-06-30 01:55:41 -0700466 "nr_bounce",
Andrew Mortone129b5c2006-09-27 01:50:00 -0700467 "nr_vmscan_write",
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700468
Christoph Lameterca889e62006-06-30 01:55:44 -0700469#ifdef CONFIG_NUMA
470 "numa_hit",
471 "numa_miss",
472 "numa_foreign",
473 "numa_interleave",
474 "numa_local",
475 "numa_other",
476#endif
477
Christoph Lameterf8891e52006-06-30 01:55:45 -0700478#ifdef CONFIG_VM_EVENT_COUNTERS
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700479 "pgpgin",
480 "pgpgout",
481 "pswpin",
482 "pswpout",
483
Christoph Lameter27bf71c2006-09-25 23:31:15 -0700484 TEXTS_FOR_ZONES("pgalloc")
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700485
486 "pgfree",
487 "pgactivate",
488 "pgdeactivate",
489
490 "pgfault",
491 "pgmajfault",
492
Christoph Lameter27bf71c2006-09-25 23:31:15 -0700493 TEXTS_FOR_ZONES("pgrefill")
494 TEXTS_FOR_ZONES("pgsteal")
495 TEXTS_FOR_ZONES("pgscan_kswapd")
496 TEXTS_FOR_ZONES("pgscan_direct")
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700497
498 "pginodesteal",
499 "slabs_scanned",
500 "kswapd_steal",
501 "kswapd_inodesteal",
502 "pageoutrun",
503 "allocstall",
504
505 "pgrotated",
Christoph Lameterf8891e52006-06-30 01:55:45 -0700506#endif
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700507};
508
509/*
510 * Output information about zones in @pgdat.
511 */
512static int zoneinfo_show(struct seq_file *m, void *arg)
513{
514 pg_data_t *pgdat = arg;
515 struct zone *zone;
516 struct zone *node_zones = pgdat->node_zones;
517 unsigned long flags;
518
519 for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; zone++) {
520 int i;
521
522 if (!populated_zone(zone))
523 continue;
524
525 spin_lock_irqsave(&zone->lock, flags);
526 seq_printf(m, "Node %d, zone %8s", pgdat->node_id, zone->name);
527 seq_printf(m,
528 "\n pages free %lu"
529 "\n min %lu"
530 "\n low %lu"
531 "\n high %lu"
532 "\n active %lu"
533 "\n inactive %lu"
534 "\n scanned %lu (a: %lu i: %lu)"
535 "\n spanned %lu"
536 "\n present %lu",
537 zone->free_pages,
538 zone->pages_min,
539 zone->pages_low,
540 zone->pages_high,
541 zone->nr_active,
542 zone->nr_inactive,
543 zone->pages_scanned,
544 zone->nr_scan_active, zone->nr_scan_inactive,
545 zone->spanned_pages,
546 zone->present_pages);
Christoph Lameter2244b952006-06-30 01:55:33 -0700547
548 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
549 seq_printf(m, "\n %-12s %lu", vmstat_text[i],
550 zone_page_state(zone, i));
551
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700552 seq_printf(m,
553 "\n protection: (%lu",
554 zone->lowmem_reserve[0]);
555 for (i = 1; i < ARRAY_SIZE(zone->lowmem_reserve); i++)
556 seq_printf(m, ", %lu", zone->lowmem_reserve[i]);
557 seq_printf(m,
558 ")"
559 "\n pagesets");
560 for_each_online_cpu(i) {
561 struct per_cpu_pageset *pageset;
562 int j;
563
564 pageset = zone_pcp(zone, i);
565 for (j = 0; j < ARRAY_SIZE(pageset->pcp); j++) {
566 if (pageset->pcp[j].count)
567 break;
568 }
569 if (j == ARRAY_SIZE(pageset->pcp))
570 continue;
571 for (j = 0; j < ARRAY_SIZE(pageset->pcp); j++) {
572 seq_printf(m,
573 "\n cpu: %i pcp: %i"
574 "\n count: %i"
575 "\n high: %i"
576 "\n batch: %i",
577 i, j,
578 pageset->pcp[j].count,
579 pageset->pcp[j].high,
580 pageset->pcp[j].batch);
581 }
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700582#ifdef CONFIG_SMP
583 seq_printf(m, "\n vm stats threshold: %d",
584 pageset->stat_threshold);
585#endif
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700586 }
587 seq_printf(m,
588 "\n all_unreclaimable: %u"
589 "\n prev_priority: %i"
590 "\n temp_priority: %i"
591 "\n start_pfn: %lu",
592 zone->all_unreclaimable,
593 zone->prev_priority,
594 zone->temp_priority,
595 zone->zone_start_pfn);
596 spin_unlock_irqrestore(&zone->lock, flags);
597 seq_putc(m, '\n');
598 }
599 return 0;
600}
601
602struct seq_operations zoneinfo_op = {
603 .start = frag_start, /* iterate over all zones. The same as in
604 * fragmentation. */
605 .next = frag_next,
606 .stop = frag_stop,
607 .show = zoneinfo_show,
608};
609
610static void *vmstat_start(struct seq_file *m, loff_t *pos)
611{
Christoph Lameter2244b952006-06-30 01:55:33 -0700612 unsigned long *v;
Christoph Lameterf8891e52006-06-30 01:55:45 -0700613#ifdef CONFIG_VM_EVENT_COUNTERS
614 unsigned long *e;
615#endif
Christoph Lameter2244b952006-06-30 01:55:33 -0700616 int i;
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700617
618 if (*pos >= ARRAY_SIZE(vmstat_text))
619 return NULL;
620
Christoph Lameterf8891e52006-06-30 01:55:45 -0700621#ifdef CONFIG_VM_EVENT_COUNTERS
Christoph Lameter2244b952006-06-30 01:55:33 -0700622 v = kmalloc(NR_VM_ZONE_STAT_ITEMS * sizeof(unsigned long)
Christoph Lameterf8891e52006-06-30 01:55:45 -0700623 + sizeof(struct vm_event_state), GFP_KERNEL);
624#else
625 v = kmalloc(NR_VM_ZONE_STAT_ITEMS * sizeof(unsigned long),
626 GFP_KERNEL);
627#endif
Christoph Lameter2244b952006-06-30 01:55:33 -0700628 m->private = v;
629 if (!v)
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700630 return ERR_PTR(-ENOMEM);
Christoph Lameter2244b952006-06-30 01:55:33 -0700631 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
632 v[i] = global_page_state(i);
Christoph Lameterf8891e52006-06-30 01:55:45 -0700633#ifdef CONFIG_VM_EVENT_COUNTERS
634 e = v + NR_VM_ZONE_STAT_ITEMS;
635 all_vm_events(e);
636 e[PGPGIN] /= 2; /* sectors -> kbytes */
637 e[PGPGOUT] /= 2;
638#endif
Christoph Lameter2244b952006-06-30 01:55:33 -0700639 return v + *pos;
Christoph Lameterf6ac2352006-06-30 01:55:32 -0700640}
641
642static void *vmstat_next(struct seq_file *m, void *arg, loff_t *pos)
643{
644 (*pos)++;
645 if (*pos >= ARRAY_SIZE(vmstat_text))
646 return NULL;
647 return (unsigned long *)m->private + *pos;
648}
649
650static int vmstat_show(struct seq_file *m, void *arg)
651{
652 unsigned long *l = arg;
653 unsigned long off = l - (unsigned long *)m->private;
654
655 seq_printf(m, "%s %lu\n", vmstat_text[off], *l);
656 return 0;
657}
658
659static void vmstat_stop(struct seq_file *m, void *arg)
660{
661 kfree(m->private);
662 m->private = NULL;
663}
664
665struct seq_operations vmstat_op = {
666 .start = vmstat_start,
667 .next = vmstat_next,
668 .stop = vmstat_stop,
669 .show = vmstat_show,
670};
671
672#endif /* CONFIG_PROC_FS */
673
Christoph Lameterdf9ecab2006-08-31 21:27:35 -0700674#ifdef CONFIG_SMP
675/*
676 * Use the cpu notifier to insure that the thresholds are recalculated
677 * when necessary.
678 */
679static int __cpuinit vmstat_cpuup_callback(struct notifier_block *nfb,
680 unsigned long action,
681 void *hcpu)
682{
683 switch (action) {
684 case CPU_UP_PREPARE:
685 case CPU_UP_CANCELED:
686 case CPU_DEAD:
687 refresh_zone_stat_thresholds();
688 break;
689 default:
690 break;
691 }
692 return NOTIFY_OK;
693}
694
695static struct notifier_block __cpuinitdata vmstat_notifier =
696 { &vmstat_cpuup_callback, NULL, 0 };
697
698int __init setup_vmstat(void)
699{
700 refresh_zone_stat_thresholds();
701 register_cpu_notifier(&vmstat_notifier);
702 return 0;
703}
704module_init(setup_vmstat)
705#endif