1
2
3
4
5
6
7
8
9
10
11#include <linux/fs.h>
12#include <linux/mm.h>
13#include <linux/err.h>
14#include <linux/module.h>
15#include <linux/slab.h>
16#include <linux/cpu.h>
17#include <linux/vmstat.h>
18#include <linux/sched.h>
19#include <linux/math64.h>
20#include <linux/writeback.h>
21#include <linux/compaction.h>
22
23#ifdef CONFIG_VM_EVENT_COUNTERS
24DEFINE_PER_CPU(struct vm_event_state, vm_event_states) = {{0}};
25EXPORT_PER_CPU_SYMBOL(vm_event_states);
26
27static void sum_vm_events(unsigned long *ret)
28{
29 int cpu;
30 int i;
31
32 memset(ret, 0, NR_VM_EVENT_ITEMS * sizeof(unsigned long));
33
34 for_each_online_cpu(cpu) {
35 struct vm_event_state *this = &per_cpu(vm_event_states, cpu);
36
37 for (i = 0; i < NR_VM_EVENT_ITEMS; i++)
38 ret[i] += this->event[i];
39 }
40}
41
42
43
44
45
46
47void all_vm_events(unsigned long *ret)
48{
49 get_online_cpus();
50 sum_vm_events(ret);
51 put_online_cpus();
52}
53EXPORT_SYMBOL_GPL(all_vm_events);
54
55#ifdef CONFIG_HOTPLUG
56
57
58
59
60
61
62void vm_events_fold_cpu(int cpu)
63{
64 struct vm_event_state *fold_state = &per_cpu(vm_event_states, cpu);
65 int i;
66
67 for (i = 0; i < NR_VM_EVENT_ITEMS; i++) {
68 count_vm_events(i, fold_state->event[i]);
69 fold_state->event[i] = 0;
70 }
71}
72#endif
73
74#endif
75
76
77
78
79
80
81atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
82EXPORT_SYMBOL(vm_stat);
83
84#ifdef CONFIG_SMP
85
86int calculate_pressure_threshold(struct zone *zone)
87{
88 int threshold;
89 int watermark_distance;
90
91
92
93
94
95
96
97
98
99 watermark_distance = low_wmark_pages(zone) - min_wmark_pages(zone);
100 threshold = max(1, (int)(watermark_distance / num_online_cpus()));
101
102
103
104
105 threshold = min(125, threshold);
106
107 return threshold;
108}
109
110int calculate_normal_threshold(struct zone *zone)
111{
112 int threshold;
113 int mem;
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145 mem = zone->present_pages >> (27 - PAGE_SHIFT);
146
147 threshold = 2 * fls(num_online_cpus()) * (1 + fls(mem));
148
149
150
151
152 threshold = min(125, threshold);
153
154 return threshold;
155}
156
157
158
159
160static void refresh_zone_stat_thresholds(void)
161{
162 struct zone *zone;
163 int cpu;
164 int threshold;
165
166 for_each_populated_zone(zone) {
167 unsigned long max_drift, tolerate_drift;
168
169 threshold = calculate_normal_threshold(zone);
170
171 for_each_online_cpu(cpu)
172 per_cpu_ptr(zone->pageset, cpu)->stat_threshold
173 = threshold;
174
175
176
177
178
179
180 tolerate_drift = low_wmark_pages(zone) - min_wmark_pages(zone);
181 max_drift = num_online_cpus() * threshold;
182 if (max_drift > tolerate_drift)
183 zone->percpu_drift_mark = high_wmark_pages(zone) +
184 max_drift;
185 }
186}
187
188void set_pgdat_percpu_threshold(pg_data_t *pgdat,
189 int (*calculate_pressure)(struct zone *))
190{
191 struct zone *zone;
192 int cpu;
193 int threshold;
194 int i;
195
196 for (i = 0; i < pgdat->nr_zones; i++) {
197 zone = &pgdat->node_zones[i];
198 if (!zone->percpu_drift_mark)
199 continue;
200
201 threshold = (*calculate_pressure)(zone);
202 for_each_possible_cpu(cpu)
203 per_cpu_ptr(zone->pageset, cpu)->stat_threshold
204 = threshold;
205 }
206}
207
208
209
210
211void __mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
212 int delta)
213{
214 struct per_cpu_pageset __percpu *pcp = zone->pageset;
215 s8 __percpu *p = pcp->vm_stat_diff + item;
216 long x;
217 long t;
218
219 x = delta + __this_cpu_read(*p);
220
221 t = __this_cpu_read(pcp->stat_threshold);
222
223 if (unlikely(x > t || x < -t)) {
224 zone_page_state_add(x, zone, item);
225 x = 0;
226 }
227 __this_cpu_write(*p, x);
228}
229EXPORT_SYMBOL(__mod_zone_page_state);
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254void __inc_zone_state(struct zone *zone, enum zone_stat_item item)
255{
256 struct per_cpu_pageset __percpu *pcp = zone->pageset;
257 s8 __percpu *p = pcp->vm_stat_diff + item;
258 s8 v, t;
259
260 v = __this_cpu_inc_return(*p);
261 t = __this_cpu_read(pcp->stat_threshold);
262 if (unlikely(v > t)) {
263 s8 overstep = t >> 1;
264
265 zone_page_state_add(v + overstep, zone, item);
266 __this_cpu_write(*p, -overstep);
267 }
268}
269
270void __inc_zone_page_state(struct page *page, enum zone_stat_item item)
271{
272 __inc_zone_state(page_zone(page), item);
273}
274EXPORT_SYMBOL(__inc_zone_page_state);
275
276void __dec_zone_state(struct zone *zone, enum zone_stat_item item)
277{
278 struct per_cpu_pageset __percpu *pcp = zone->pageset;
279 s8 __percpu *p = pcp->vm_stat_diff + item;
280 s8 v, t;
281
282 v = __this_cpu_dec_return(*p);
283 t = __this_cpu_read(pcp->stat_threshold);
284 if (unlikely(v < - t)) {
285 s8 overstep = t >> 1;
286
287 zone_page_state_add(v - overstep, zone, item);
288 __this_cpu_write(*p, overstep);
289 }
290}
291
292void __dec_zone_page_state(struct page *page, enum zone_stat_item item)
293{
294 __dec_zone_state(page_zone(page), item);
295}
296EXPORT_SYMBOL(__dec_zone_page_state);
297
298#ifdef CONFIG_CMPXCHG_LOCAL
299
300
301
302
303
304
305
306
307
308
309
310
311static inline void mod_state(struct zone *zone,
312 enum zone_stat_item item, int delta, int overstep_mode)
313{
314 struct per_cpu_pageset __percpu *pcp = zone->pageset;
315 s8 __percpu *p = pcp->vm_stat_diff + item;
316 long o, n, t, z;
317
318 do {
319 z = 0;
320
321
322
323
324
325
326
327
328 t = this_cpu_read(pcp->stat_threshold);
329
330 o = this_cpu_read(*p);
331 n = delta + o;
332
333 if (n > t || n < -t) {
334 int os = overstep_mode * (t >> 1) ;
335
336
337 z = n + os;
338 n = -os;
339 }
340 } while (this_cpu_cmpxchg(*p, o, n) != o);
341
342 if (z)
343 zone_page_state_add(z, zone, item);
344}
345
346void mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
347 int delta)
348{
349 mod_state(zone, item, delta, 0);
350}
351EXPORT_SYMBOL(mod_zone_page_state);
352
353void inc_zone_state(struct zone *zone, enum zone_stat_item item)
354{
355 mod_state(zone, item, 1, 1);
356}
357
358void inc_zone_page_state(struct page *page, enum zone_stat_item item)
359{
360 mod_state(page_zone(page), item, 1, 1);
361}
362EXPORT_SYMBOL(inc_zone_page_state);
363
364void dec_zone_page_state(struct page *page, enum zone_stat_item item)
365{
366 mod_state(page_zone(page), item, -1, -1);
367}
368EXPORT_SYMBOL(dec_zone_page_state);
369#else
370
371
372
373void mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
374 int delta)
375{
376 unsigned long flags;
377
378 local_irq_save(flags);
379 __mod_zone_page_state(zone, item, delta);
380 local_irq_restore(flags);
381}
382EXPORT_SYMBOL(mod_zone_page_state);
383
384void inc_zone_state(struct zone *zone, enum zone_stat_item item)
385{
386 unsigned long flags;
387
388 local_irq_save(flags);
389 __inc_zone_state(zone, item);
390 local_irq_restore(flags);
391}
392
393void inc_zone_page_state(struct page *page, enum zone_stat_item item)
394{
395 unsigned long flags;
396 struct zone *zone;
397
398 zone = page_zone(page);
399 local_irq_save(flags);
400 __inc_zone_state(zone, item);
401 local_irq_restore(flags);
402}
403EXPORT_SYMBOL(inc_zone_page_state);
404
405void dec_zone_page_state(struct page *page, enum zone_stat_item item)
406{
407 unsigned long flags;
408
409 local_irq_save(flags);
410 __dec_zone_page_state(page, item);
411 local_irq_restore(flags);
412}
413EXPORT_SYMBOL(dec_zone_page_state);
414#endif
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434void refresh_cpu_vm_stats(int cpu)
435{
436 struct zone *zone;
437 int i;
438 int global_diff[NR_VM_ZONE_STAT_ITEMS] = { 0, };
439
440 for_each_populated_zone(zone) {
441 struct per_cpu_pageset *p;
442
443 p = per_cpu_ptr(zone->pageset, cpu);
444
445 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
446 if (p->vm_stat_diff[i]) {
447 unsigned long flags;
448 int v;
449
450 local_irq_save(flags);
451 v = p->vm_stat_diff[i];
452 p->vm_stat_diff[i] = 0;
453 local_irq_restore(flags);
454 atomic_long_add(v, &zone->vm_stat[i]);
455 global_diff[i] += v;
456#ifdef CONFIG_NUMA
457
458 p->expire = 3;
459#endif
460 }
461 cond_resched();
462#ifdef CONFIG_NUMA
463
464
465
466
467
468
469
470 if (!p->expire || !p->pcp.count)
471 continue;
472
473
474
475
476 if (zone_to_nid(zone) == numa_node_id()) {
477 p->expire = 0;
478 continue;
479 }
480
481 p->expire--;
482 if (p->expire)
483 continue;
484
485 if (p->pcp.count)
486 drain_zone_pages(zone, &p->pcp);
487#endif
488 }
489
490 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
491 if (global_diff[i])
492 atomic_long_add(global_diff[i], &vm_stat[i]);
493}
494
495#endif
496
497#ifdef CONFIG_NUMA
498
499
500
501
502
503
504void zone_statistics(struct zone *preferred_zone, struct zone *z)
505{
506 if (z->zone_pgdat == preferred_zone->zone_pgdat) {
507 __inc_zone_state(z, NUMA_HIT);
508 } else {
509 __inc_zone_state(z, NUMA_MISS);
510 __inc_zone_state(preferred_zone, NUMA_FOREIGN);
511 }
512 if (z->node == numa_node_id())
513 __inc_zone_state(z, NUMA_LOCAL);
514 else
515 __inc_zone_state(z, NUMA_OTHER);
516}
517#endif
518
519#ifdef CONFIG_COMPACTION
520
521struct contig_page_info {
522 unsigned long free_pages;
523 unsigned long free_blocks_total;
524 unsigned long free_blocks_suitable;
525};
526
527
528
529
530
531
532
533
534
535static void fill_contig_page_info(struct zone *zone,
536 unsigned int suitable_order,
537 struct contig_page_info *info)
538{
539 unsigned int order;
540
541 info->free_pages = 0;
542 info->free_blocks_total = 0;
543 info->free_blocks_suitable = 0;
544
545 for (order = 0; order < MAX_ORDER; order++) {
546 unsigned long blocks;
547
548
549 blocks = zone->free_area[order].nr_free;
550 info->free_blocks_total += blocks;
551
552
553 info->free_pages += blocks << order;
554
555
556 if (order >= suitable_order)
557 info->free_blocks_suitable += blocks <<
558 (order - suitable_order);
559 }
560}
561
562
563
564
565
566
567
568
569static int __fragmentation_index(unsigned int order, struct contig_page_info *info)
570{
571 unsigned long requested = 1UL << order;
572
573 if (!info->free_blocks_total)
574 return 0;
575
576
577 if (info->free_blocks_suitable)
578 return -1000;
579
580
581
582
583
584
585
586 return 1000 - div_u64( (1000+(div_u64(info->free_pages * 1000ULL, requested))), info->free_blocks_total);
587}
588
589
590int fragmentation_index(struct zone *zone, unsigned int order)
591{
592 struct contig_page_info info;
593
594 fill_contig_page_info(zone, order, &info);
595 return __fragmentation_index(order, &info);
596}
597#endif
598
599#if defined(CONFIG_PROC_FS) || defined(CONFIG_COMPACTION)
600#include <linux/proc_fs.h>
601#include <linux/seq_file.h>
602
603static char * const migratetype_names[MIGRATE_TYPES] = {
604 "Unmovable",
605 "Reclaimable",
606 "Movable",
607 "Reserve",
608 "Isolate",
609};
610
611static void *frag_start(struct seq_file *m, loff_t *pos)
612{
613 pg_data_t *pgdat;
614 loff_t node = *pos;
615 for (pgdat = first_online_pgdat();
616 pgdat && node;
617 pgdat = next_online_pgdat(pgdat))
618 --node;
619
620 return pgdat;
621}
622
623static void *frag_next(struct seq_file *m, void *arg, loff_t *pos)
624{
625 pg_data_t *pgdat = (pg_data_t *)arg;
626
627 (*pos)++;
628 return next_online_pgdat(pgdat);
629}
630
631static void frag_stop(struct seq_file *m, void *arg)
632{
633}
634
635
636static void walk_zones_in_node(struct seq_file *m, pg_data_t *pgdat,
637 void (*print)(struct seq_file *m, pg_data_t *, struct zone *))
638{
639 struct zone *zone;
640 struct zone *node_zones = pgdat->node_zones;
641 unsigned long flags;
642
643 for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) {
644 if (!populated_zone(zone))
645 continue;
646
647 spin_lock_irqsave(&zone->lock, flags);
648 print(m, pgdat, zone);
649 spin_unlock_irqrestore(&zone->lock, flags);
650 }
651}
652#endif
653
654#ifdef CONFIG_PROC_FS
655static void frag_show_print(struct seq_file *m, pg_data_t *pgdat,
656 struct zone *zone)
657{
658 int order;
659
660 seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name);
661 for (order = 0; order < MAX_ORDER; ++order)
662 seq_printf(m, "%6lu ", zone->free_area[order].nr_free);
663 seq_putc(m, '\n');
664}
665
666
667
668
669static int frag_show(struct seq_file *m, void *arg)
670{
671 pg_data_t *pgdat = (pg_data_t *)arg;
672 walk_zones_in_node(m, pgdat, frag_show_print);
673 return 0;
674}
675
676static void pagetypeinfo_showfree_print(struct seq_file *m,
677 pg_data_t *pgdat, struct zone *zone)
678{
679 int order, mtype;
680
681 for (mtype = 0; mtype < MIGRATE_TYPES; mtype++) {
682 seq_printf(m, "Node %4d, zone %8s, type %12s ",
683 pgdat->node_id,
684 zone->name,
685 migratetype_names[mtype]);
686 for (order = 0; order < MAX_ORDER; ++order) {
687 unsigned long freecount = 0;
688 struct free_area *area;
689 struct list_head *curr;
690
691 area = &(zone->free_area[order]);
692
693 list_for_each(curr, &area->free_list[mtype])
694 freecount++;
695 seq_printf(m, "%6lu ", freecount);
696 }
697 seq_putc(m, '\n');
698 }
699}
700
701
702static int pagetypeinfo_showfree(struct seq_file *m, void *arg)
703{
704 int order;
705 pg_data_t *pgdat = (pg_data_t *)arg;
706
707
708 seq_printf(m, "%-43s ", "Free pages count per migrate type at order");
709 for (order = 0; order < MAX_ORDER; ++order)
710 seq_printf(m, "%6d ", order);
711 seq_putc(m, '\n');
712
713 walk_zones_in_node(m, pgdat, pagetypeinfo_showfree_print);
714
715 return 0;
716}
717
718static void pagetypeinfo_showblockcount_print(struct seq_file *m,
719 pg_data_t *pgdat, struct zone *zone)
720{
721 int mtype;
722 unsigned long pfn;
723 unsigned long start_pfn = zone->zone_start_pfn;
724 unsigned long end_pfn = start_pfn + zone->spanned_pages;
725 unsigned long count[MIGRATE_TYPES] = { 0, };
726
727 for (pfn = start_pfn; pfn < end_pfn; pfn += pageblock_nr_pages) {
728 struct page *page;
729
730 if (!pfn_valid(pfn))
731 continue;
732
733 page = pfn_to_page(pfn);
734
735
736 if (!memmap_valid_within(pfn, page, zone))
737 continue;
738
739 mtype = get_pageblock_migratetype(page);
740
741 if (mtype < MIGRATE_TYPES)
742 count[mtype]++;
743 }
744
745
746 seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name);
747 for (mtype = 0; mtype < MIGRATE_TYPES; mtype++)
748 seq_printf(m, "%12lu ", count[mtype]);
749 seq_putc(m, '\n');
750}
751
752
753static int pagetypeinfo_showblockcount(struct seq_file *m, void *arg)
754{
755 int mtype;
756 pg_data_t *pgdat = (pg_data_t *)arg;
757
758 seq_printf(m, "\n%-23s", "Number of blocks type ");
759 for (mtype = 0; mtype < MIGRATE_TYPES; mtype++)
760 seq_printf(m, "%12s ", migratetype_names[mtype]);
761 seq_putc(m, '\n');
762 walk_zones_in_node(m, pgdat, pagetypeinfo_showblockcount_print);
763
764 return 0;
765}
766
767
768
769
770
771static int pagetypeinfo_show(struct seq_file *m, void *arg)
772{
773 pg_data_t *pgdat = (pg_data_t *)arg;
774
775
776 if (!node_state(pgdat->node_id, N_HIGH_MEMORY))
777 return 0;
778
779 seq_printf(m, "Page block order: %d\n", pageblock_order);
780 seq_printf(m, "Pages per block: %lu\n", pageblock_nr_pages);
781 seq_putc(m, '\n');
782 pagetypeinfo_showfree(m, pgdat);
783 pagetypeinfo_showblockcount(m, pgdat);
784
785 return 0;
786}
787
788static const struct seq_operations fragmentation_op = {
789 .start = frag_start,
790 .next = frag_next,
791 .stop = frag_stop,
792 .show = frag_show,
793};
794
795static int fragmentation_open(struct inode *inode, struct file *file)
796{
797 return seq_open(file, &fragmentation_op);
798}
799
800static const struct file_operations fragmentation_file_operations = {
801 .open = fragmentation_open,
802 .read = seq_read,
803 .llseek = seq_lseek,
804 .release = seq_release,
805};
806
807static const struct seq_operations pagetypeinfo_op = {
808 .start = frag_start,
809 .next = frag_next,
810 .stop = frag_stop,
811 .show = pagetypeinfo_show,
812};
813
814static int pagetypeinfo_open(struct inode *inode, struct file *file)
815{
816 return seq_open(file, &pagetypeinfo_op);
817}
818
819static const struct file_operations pagetypeinfo_file_ops = {
820 .open = pagetypeinfo_open,
821 .read = seq_read,
822 .llseek = seq_lseek,
823 .release = seq_release,
824};
825
826#ifdef CONFIG_ZONE_DMA
827#define TEXT_FOR_DMA(xx) xx "_dma",
828#else
829#define TEXT_FOR_DMA(xx)
830#endif
831
832#ifdef CONFIG_ZONE_DMA32
833#define TEXT_FOR_DMA32(xx) xx "_dma32",
834#else
835#define TEXT_FOR_DMA32(xx)
836#endif
837
838#ifdef CONFIG_HIGHMEM
839#define TEXT_FOR_HIGHMEM(xx) xx "_high",
840#else
841#define TEXT_FOR_HIGHMEM(xx)
842#endif
843
844#define TEXTS_FOR_ZONES(xx) TEXT_FOR_DMA(xx) TEXT_FOR_DMA32(xx) xx "_normal", \
845 TEXT_FOR_HIGHMEM(xx) xx "_movable",
846
847static const char * const vmstat_text[] = {
848
849 "nr_free_pages",
850 "nr_inactive_anon",
851 "nr_active_anon",
852 "nr_inactive_file",
853 "nr_active_file",
854 "nr_unevictable",
855 "nr_mlock",
856 "nr_anon_pages",
857 "nr_mapped",
858 "nr_file_pages",
859 "nr_dirty",
860 "nr_writeback",
861 "nr_slab_reclaimable",
862 "nr_slab_unreclaimable",
863 "nr_page_table_pages",
864 "nr_kernel_stack",
865 "nr_unstable",
866 "nr_bounce",
867 "nr_vmscan_write",
868 "nr_writeback_temp",
869 "nr_isolated_anon",
870 "nr_isolated_file",
871 "nr_shmem",
872 "nr_dirtied",
873 "nr_written",
874
875#ifdef CONFIG_NUMA
876 "numa_hit",
877 "numa_miss",
878 "numa_foreign",
879 "numa_interleave",
880 "numa_local",
881 "numa_other",
882#endif
883 "nr_anon_transparent_hugepages",
884 "nr_dirty_threshold",
885 "nr_dirty_background_threshold",
886
887#ifdef CONFIG_VM_EVENT_COUNTERS
888 "pgpgin",
889 "pgpgout",
890 "pswpin",
891 "pswpout",
892
893 TEXTS_FOR_ZONES("pgalloc")
894
895 "pgfree",
896 "pgactivate",
897 "pgdeactivate",
898
899 "pgfault",
900 "pgmajfault",
901
902 TEXTS_FOR_ZONES("pgrefill")
903 TEXTS_FOR_ZONES("pgsteal")
904 TEXTS_FOR_ZONES("pgscan_kswapd")
905 TEXTS_FOR_ZONES("pgscan_direct")
906
907#ifdef CONFIG_NUMA
908 "zone_reclaim_failed",
909#endif
910 "pginodesteal",
911 "slabs_scanned",
912 "kswapd_steal",
913 "kswapd_inodesteal",
914 "kswapd_low_wmark_hit_quickly",
915 "kswapd_high_wmark_hit_quickly",
916 "kswapd_skip_congestion_wait",
917 "pageoutrun",
918 "allocstall",
919
920 "pgrotated",
921
922#ifdef CONFIG_COMPACTION
923 "compact_blocks_moved",
924 "compact_pages_moved",
925 "compact_pagemigrate_failed",
926 "compact_stall",
927 "compact_fail",
928 "compact_success",
929#endif
930
931#ifdef CONFIG_HUGETLB_PAGE
932 "htlb_buddy_alloc_success",
933 "htlb_buddy_alloc_fail",
934#endif
935 "unevictable_pgs_culled",
936 "unevictable_pgs_scanned",
937 "unevictable_pgs_rescued",
938 "unevictable_pgs_mlocked",
939 "unevictable_pgs_munlocked",
940 "unevictable_pgs_cleared",
941 "unevictable_pgs_stranded",
942 "unevictable_pgs_mlockfreed",
943#endif
944};
945
946static void zoneinfo_show_print(struct seq_file *m, pg_data_t *pgdat,
947 struct zone *zone)
948{
949 int i;
950 seq_printf(m, "Node %d, zone %8s", pgdat->node_id, zone->name);
951 seq_printf(m,
952 "\n pages free %lu"
953 "\n min %lu"
954 "\n low %lu"
955 "\n high %lu"
956 "\n scanned %lu"
957 "\n spanned %lu"
958 "\n present %lu",
959 zone_page_state(zone, NR_FREE_PAGES),
960 min_wmark_pages(zone),
961 low_wmark_pages(zone),
962 high_wmark_pages(zone),
963 zone->pages_scanned,
964 zone->spanned_pages,
965 zone->present_pages);
966
967 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
968 seq_printf(m, "\n %-12s %lu", vmstat_text[i],
969 zone_page_state(zone, i));
970
971 seq_printf(m,
972 "\n protection: (%lu",
973 zone->lowmem_reserve[0]);
974 for (i = 1; i < ARRAY_SIZE(zone->lowmem_reserve); i++)
975 seq_printf(m, ", %lu", zone->lowmem_reserve[i]);
976 seq_printf(m,
977 ")"
978 "\n pagesets");
979 for_each_online_cpu(i) {
980 struct per_cpu_pageset *pageset;
981
982 pageset = per_cpu_ptr(zone->pageset, i);
983 seq_printf(m,
984 "\n cpu: %i"
985 "\n count: %i"
986 "\n high: %i"
987 "\n batch: %i",
988 i,
989 pageset->pcp.count,
990 pageset->pcp.high,
991 pageset->pcp.batch);
992#ifdef CONFIG_SMP
993 seq_printf(m, "\n vm stats threshold: %d",
994 pageset->stat_threshold);
995#endif
996 }
997 seq_printf(m,
998 "\n all_unreclaimable: %u"
999 "\n start_pfn: %lu"
1000 "\n inactive_ratio: %u",
1001 zone->all_unreclaimable,
1002 zone->zone_start_pfn,
1003 zone->inactive_ratio);
1004 seq_putc(m, '\n');
1005}
1006
1007
1008
1009
1010static int zoneinfo_show(struct seq_file *m, void *arg)
1011{
1012 pg_data_t *pgdat = (pg_data_t *)arg;
1013 walk_zones_in_node(m, pgdat, zoneinfo_show_print);
1014 return 0;
1015}
1016
1017static const struct seq_operations zoneinfo_op = {
1018 .start = frag_start,
1019
1020 .next = frag_next,
1021 .stop = frag_stop,
1022 .show = zoneinfo_show,
1023};
1024
1025static int zoneinfo_open(struct inode *inode, struct file *file)
1026{
1027 return seq_open(file, &zoneinfo_op);
1028}
1029
1030static const struct file_operations proc_zoneinfo_file_operations = {
1031 .open = zoneinfo_open,
1032 .read = seq_read,
1033 .llseek = seq_lseek,
1034 .release = seq_release,
1035};
1036
1037enum writeback_stat_item {
1038 NR_DIRTY_THRESHOLD,
1039 NR_DIRTY_BG_THRESHOLD,
1040 NR_VM_WRITEBACK_STAT_ITEMS,
1041};
1042
1043static void *vmstat_start(struct seq_file *m, loff_t *pos)
1044{
1045 unsigned long *v;
1046 int i, stat_items_size;
1047
1048 if (*pos >= ARRAY_SIZE(vmstat_text))
1049 return NULL;
1050 stat_items_size = NR_VM_ZONE_STAT_ITEMS * sizeof(unsigned long) +
1051 NR_VM_WRITEBACK_STAT_ITEMS * sizeof(unsigned long);
1052
1053#ifdef CONFIG_VM_EVENT_COUNTERS
1054 stat_items_size += sizeof(struct vm_event_state);
1055#endif
1056
1057 v = kmalloc(stat_items_size, GFP_KERNEL);
1058 m->private = v;
1059 if (!v)
1060 return ERR_PTR(-ENOMEM);
1061 for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
1062 v[i] = global_page_state(i);
1063 v += NR_VM_ZONE_STAT_ITEMS;
1064
1065 global_dirty_limits(v + NR_DIRTY_BG_THRESHOLD,
1066 v + NR_DIRTY_THRESHOLD);
1067 v += NR_VM_WRITEBACK_STAT_ITEMS;
1068
1069#ifdef CONFIG_VM_EVENT_COUNTERS
1070 all_vm_events(v);
1071 v[PGPGIN] /= 2;
1072 v[PGPGOUT] /= 2;
1073#endif
1074 return (unsigned long *)m->private + *pos;
1075}
1076
1077static void *vmstat_next(struct seq_file *m, void *arg, loff_t *pos)
1078{
1079 (*pos)++;
1080 if (*pos >= ARRAY_SIZE(vmstat_text))
1081 return NULL;
1082 return (unsigned long *)m->private + *pos;
1083}
1084
1085static int vmstat_show(struct seq_file *m, void *arg)
1086{
1087 unsigned long *l = arg;
1088 unsigned long off = l - (unsigned long *)m->private;
1089
1090 seq_printf(m, "%s %lu\n", vmstat_text[off], *l);
1091 return 0;
1092}
1093
1094static void vmstat_stop(struct seq_file *m, void *arg)
1095{
1096 kfree(m->private);
1097 m->private = NULL;
1098}
1099
1100static const struct seq_operations vmstat_op = {
1101 .start = vmstat_start,
1102 .next = vmstat_next,
1103 .stop = vmstat_stop,
1104 .show = vmstat_show,
1105};
1106
1107static int vmstat_open(struct inode *inode, struct file *file)
1108{
1109 return seq_open(file, &vmstat_op);
1110}
1111
1112static const struct file_operations proc_vmstat_file_operations = {
1113 .open = vmstat_open,
1114 .read = seq_read,
1115 .llseek = seq_lseek,
1116 .release = seq_release,
1117};
1118#endif
1119
1120#ifdef CONFIG_SMP
1121static DEFINE_PER_CPU(struct delayed_work, vmstat_work);
1122int sysctl_stat_interval __read_mostly = HZ;
1123
1124static void vmstat_update(struct work_struct *w)
1125{
1126 refresh_cpu_vm_stats(smp_processor_id());
1127 schedule_delayed_work(&__get_cpu_var(vmstat_work),
1128 round_jiffies_relative(sysctl_stat_interval));
1129}
1130
1131static void __cpuinit start_cpu_timer(int cpu)
1132{
1133 struct delayed_work *work = &per_cpu(vmstat_work, cpu);
1134
1135 INIT_DELAYED_WORK_DEFERRABLE(work, vmstat_update);
1136 schedule_delayed_work_on(cpu, work, __round_jiffies_relative(HZ, cpu));
1137}
1138
1139
1140
1141
1142
1143static int __cpuinit vmstat_cpuup_callback(struct notifier_block *nfb,
1144 unsigned long action,
1145 void *hcpu)
1146{
1147 long cpu = (long)hcpu;
1148
1149 switch (action) {
1150 case CPU_ONLINE:
1151 case CPU_ONLINE_FROZEN:
1152 refresh_zone_stat_thresholds();
1153 start_cpu_timer(cpu);
1154 node_set_state(cpu_to_node(cpu), N_CPU);
1155 break;
1156 case CPU_DOWN_PREPARE:
1157 case CPU_DOWN_PREPARE_FROZEN:
1158 cancel_delayed_work_sync(&per_cpu(vmstat_work, cpu));
1159 per_cpu(vmstat_work, cpu).work.func = NULL;
1160 break;
1161 case CPU_DOWN_FAILED:
1162 case CPU_DOWN_FAILED_FROZEN:
1163 start_cpu_timer(cpu);
1164 break;
1165 case CPU_DEAD:
1166 case CPU_DEAD_FROZEN:
1167 refresh_zone_stat_thresholds();
1168 break;
1169 default:
1170 break;
1171 }
1172 return NOTIFY_OK;
1173}
1174
1175static struct notifier_block __cpuinitdata vmstat_notifier =
1176 { &vmstat_cpuup_callback, NULL, 0 };
1177#endif
1178
1179static int __init setup_vmstat(void)
1180{
1181#ifdef CONFIG_SMP
1182 int cpu;
1183
1184 refresh_zone_stat_thresholds();
1185 register_cpu_notifier(&vmstat_notifier);
1186
1187 for_each_online_cpu(cpu)
1188 start_cpu_timer(cpu);
1189#endif
1190#ifdef CONFIG_PROC_FS
1191 proc_create("buddyinfo", S_IRUGO, NULL, &fragmentation_file_operations);
1192 proc_create("pagetypeinfo", S_IRUGO, NULL, &pagetypeinfo_file_ops);
1193 proc_create("vmstat", S_IRUGO, NULL, &proc_vmstat_file_operations);
1194 proc_create("zoneinfo", S_IRUGO, NULL, &proc_zoneinfo_file_operations);
1195#endif
1196 return 0;
1197}
1198module_init(setup_vmstat)
1199
1200#if defined(CONFIG_DEBUG_FS) && defined(CONFIG_COMPACTION)
1201#include <linux/debugfs.h>
1202
1203static struct dentry *extfrag_debug_root;
1204
1205
1206
1207
1208
1209static int unusable_free_index(unsigned int order,
1210 struct contig_page_info *info)
1211{
1212
1213 if (info->free_pages == 0)
1214 return 1000;
1215
1216
1217
1218
1219
1220
1221
1222
1223 return div_u64((info->free_pages - (info->free_blocks_suitable << order)) * 1000ULL, info->free_pages);
1224
1225}
1226
1227static void unusable_show_print(struct seq_file *m,
1228 pg_data_t *pgdat, struct zone *zone)
1229{
1230 unsigned int order;
1231 int index;
1232 struct contig_page_info info;
1233
1234 seq_printf(m, "Node %d, zone %8s ",
1235 pgdat->node_id,
1236 zone->name);
1237 for (order = 0; order < MAX_ORDER; ++order) {
1238 fill_contig_page_info(zone, order, &info);
1239 index = unusable_free_index(order, &info);
1240 seq_printf(m, "%d.%03d ", index / 1000, index % 1000);
1241 }
1242
1243 seq_putc(m, '\n');
1244}
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255static int unusable_show(struct seq_file *m, void *arg)
1256{
1257 pg_data_t *pgdat = (pg_data_t *)arg;
1258
1259
1260 if (!node_state(pgdat->node_id, N_HIGH_MEMORY))
1261 return 0;
1262
1263 walk_zones_in_node(m, pgdat, unusable_show_print);
1264
1265 return 0;
1266}
1267
1268static const struct seq_operations unusable_op = {
1269 .start = frag_start,
1270 .next = frag_next,
1271 .stop = frag_stop,
1272 .show = unusable_show,
1273};
1274
1275static int unusable_open(struct inode *inode, struct file *file)
1276{
1277 return seq_open(file, &unusable_op);
1278}
1279
1280static const struct file_operations unusable_file_ops = {
1281 .open = unusable_open,
1282 .read = seq_read,
1283 .llseek = seq_lseek,
1284 .release = seq_release,
1285};
1286
1287static void extfrag_show_print(struct seq_file *m,
1288 pg_data_t *pgdat, struct zone *zone)
1289{
1290 unsigned int order;
1291 int index;
1292
1293
1294 struct contig_page_info info;
1295
1296 seq_printf(m, "Node %d, zone %8s ",
1297 pgdat->node_id,
1298 zone->name);
1299 for (order = 0; order < MAX_ORDER; ++order) {
1300 fill_contig_page_info(zone, order, &info);
1301 index = __fragmentation_index(order, &info);
1302 seq_printf(m, "%d.%03d ", index / 1000, index % 1000);
1303 }
1304
1305 seq_putc(m, '\n');
1306}
1307
1308
1309
1310
1311static int extfrag_show(struct seq_file *m, void *arg)
1312{
1313 pg_data_t *pgdat = (pg_data_t *)arg;
1314
1315 walk_zones_in_node(m, pgdat, extfrag_show_print);
1316
1317 return 0;
1318}
1319
1320static const struct seq_operations extfrag_op = {
1321 .start = frag_start,
1322 .next = frag_next,
1323 .stop = frag_stop,
1324 .show = extfrag_show,
1325};
1326
1327static int extfrag_open(struct inode *inode, struct file *file)
1328{
1329 return seq_open(file, &extfrag_op);
1330}
1331
1332static const struct file_operations extfrag_file_ops = {
1333 .open = extfrag_open,
1334 .read = seq_read,
1335 .llseek = seq_lseek,
1336 .release = seq_release,
1337};
1338
1339static int __init extfrag_debug_init(void)
1340{
1341 extfrag_debug_root = debugfs_create_dir("extfrag", NULL);
1342 if (!extfrag_debug_root)
1343 return -ENOMEM;
1344
1345 if (!debugfs_create_file("unusable_index", 0444,
1346 extfrag_debug_root, NULL, &unusable_file_ops))
1347 return -ENOMEM;
1348
1349 if (!debugfs_create_file("extfrag_index", 0444,
1350 extfrag_debug_root, NULL, &extfrag_file_ops))
1351 return -ENOMEM;
1352
1353 return 0;
1354}
1355
1356module_init(extfrag_debug_init);
1357#endif
1358