Kernel

Kernel Git Source Tree

Root/mm/vmstat.c

1	/*
2	* linux/mm/vmstat.c
3	*
4	* Manages VM statistics
5	* Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
6	*
7	* zoned VM statistics
8	* Copyright (C) 2006 Silicon Graphics, Inc.,
9	* Christoph Lameter <christoph@lameter.com>
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
24	DEFINE_PER_CPU(struct vm_event_state, vm_event_states) = {{0}};
25	EXPORT_PER_CPU_SYMBOL(vm_event_states);
26
27	static 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	* Accumulate the vm event counters across all CPUs.
44	* The result is unavoidably approximate - it can change
45	* during and after execution of this function.
46	*/
47	void all_vm_events(unsigned long *ret)
48	{
49	get_online_cpus();
50	sum_vm_events(ret);
51	put_online_cpus();
52	}
53	EXPORT_SYMBOL_GPL(all_vm_events);
54
55	#ifdef CONFIG_HOTPLUG
56	/*
57	* Fold the foreign cpu events into our own.
58	*
59	* This is adding to the events on one processor
60	* but keeps the global counts constant.
61	*/
62	void 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 /* CONFIG_HOTPLUG */
73
74	#endif /* CONFIG_VM_EVENT_COUNTERS */
75
76	/*
77	* Manage combined zone based / global counters
78	*
79	* vm_stat contains the global counters
80	*/
81	atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS] __cacheline_aligned_in_smp;
82	EXPORT_SYMBOL(vm_stat);
83
84	#ifdef CONFIG_SMP
85
86	int calculate_pressure_threshold(struct zone *zone)
87	{
88	int threshold;
89	int watermark_distance;
90
91	/*
92	* As vmstats are not up to date, there is drift between the estimated
93	* and real values. For high thresholds and a high number of CPUs, it
94	* is possible for the min watermark to be breached while the estimated
95	* value looks fine. The pressure threshold is a reduced value such
96	* that even the maximum amount of drift will not accidentally breach
97	* the min watermark
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	* Maximum threshold is 125
104	*/
105	threshold = min(125, threshold);
106
107	return threshold;
108	}
109
110	int calculate_normal_threshold(struct zone *zone)
111	{
112	int threshold;
113	int mem; /* memory in 128 MB units */
114
115	/*
116	* The threshold scales with the number of processors and the amount
117	* of memory per zone. More memory means that we can defer updates for
118	* longer, more processors could lead to more contention.
119	* fls() is used to have a cheap way of logarithmic scaling.
120	*
121	* Some sample thresholds:
122	*
123	* Threshold Processors (fls) Zonesize fls(mem+1)
124	* ------------------------------------------------------------------
125	* 8 1 1 0.9-1 GB 4
126	* 16 2 2 0.9-1 GB 4
127	* 20 2 2 1-2 GB 5
128	* 24 2 2 2-4 GB 6
129	* 28 2 2 4-8 GB 7
130	* 32 2 2 8-16 GB 8
131	* 4 2 2 <128M 1
132	* 30 4 3 2-4 GB 5
133	* 48 4 3 8-16 GB 8
134	* 32 8 4 1-2 GB 4
135	* 32 8 4 0.9-1GB 4
136	* 10 16 5 <128M 1
137	* 40 16 5 900M 4
138	* 70 64 7 2-4 GB 5
139	* 84 64 7 4-8 GB 6
140	* 108 512 9 4-8 GB 6
141	* 125 1024 10 8-16 GB 8
142	* 125 1024 10 16-32 GB 9
143	*/
144
145	mem = zone->present_pages >> (27 - PAGE_SHIFT);
146
147	threshold = 2 * fls(num_online_cpus()) * (1 + fls(mem));
148
149	/*
150	* Maximum threshold is 125
151	*/
152	threshold = min(125, threshold);
153
154	return threshold;
155	}
156
157	/*
158	* Refresh the thresholds for each zone.
159	*/
160	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	* Only set percpu_drift_mark if there is a danger that
177	* NR_FREE_PAGES reports the low watermark is ok when in fact
178	* the min watermark could be breached by an allocation
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
188	void 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	* For use when we know that interrupts are disabled.
210	*/
211	void __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	}
229	EXPORT_SYMBOL(__mod_zone_page_state);
230
231	/*
232	* Optimized increment and decrement functions.
233	*
234	* These are only for a single page and therefore can take a struct page *
235	* argument instead of struct zone *. This allows the inclusion of the code
236	* generated for page_zone(page) into the optimized functions.
237	*
238	* No overflow check is necessary and therefore the differential can be
239	* incremented or decremented in place which may allow the compilers to
240	* generate better code.
241	* The increment or decrement is known and therefore one boundary check can
242	* be omitted.
243	*
244	* NOTE: These functions are very performance sensitive. Change only
245	* with care.
246	*
247	* Some processors have inc/dec instructions that are atomic vs an interrupt.
248	* However, the code must first determine the differential location in a zone
249	* based on the processor number and then inc/dec the counter. There is no
250	* guarantee without disabling preemption that the processor will not change
251	* in between and therefore the atomicity vs. interrupt cannot be exploited
252	* in a useful way here.
253	*/
254	void __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
270	void __inc_zone_page_state(struct page *page, enum zone_stat_item item)
271	{
272	__inc_zone_state(page_zone(page), item);
273	}
274	EXPORT_SYMBOL(__inc_zone_page_state);
275
276	void __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
292	void __dec_zone_page_state(struct page *page, enum zone_stat_item item)
293	{
294	__dec_zone_state(page_zone(page), item);
295	}
296	EXPORT_SYMBOL(__dec_zone_page_state);
297
298	#ifdef CONFIG_HAVE_CMPXCHG_LOCAL
299	/*
300	* If we have cmpxchg_local support then we do not need to incur the overhead
301	* that comes with local_irq_save/restore if we use this_cpu_cmpxchg.
302	*
303	* mod_state() modifies the zone counter state through atomic per cpu
304	* operations.
305	*
306	* Overstep mode specifies how overstep should handled:
307	* 0 No overstepping
308	* 1 Overstepping half of threshold
309	* -1 Overstepping minus half of threshold
310	*/
311	static 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; /* overflow to zone counters */
320
321	/*
322	* The fetching of the stat_threshold is racy. We may apply
323	* a counter threshold to the wrong the cpu if we get
324	* rescheduled while executing here. However, the next
325	* counter update will apply the threshold again and
326	* therefore bring the counter under the threshold again.
327	*
328	* Most of the time the thresholds are the same anyways
329	* for all cpus in a zone.
330	*/
331	t = this_cpu_read(pcp->stat_threshold);
332
333	o = this_cpu_read(*p);
334	n = delta + o;
335
336	if (n > t \|\| n < -t) {
337	int os = overstep_mode * (t >> 1) ;
338
339	/* Overflow must be added to zone counters */
340	z = n + os;
341	n = -os;
342	}
343	} while (this_cpu_cmpxchg(*p, o, n) != o);
344
345	if (z)
346	zone_page_state_add(z, zone, item);
347	}
348
349	void mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
350	int delta)
351	{
352	mod_state(zone, item, delta, 0);
353	}
354	EXPORT_SYMBOL(mod_zone_page_state);
355
356	void inc_zone_state(struct zone *zone, enum zone_stat_item item)
357	{
358	mod_state(zone, item, 1, 1);
359	}
360
361	void inc_zone_page_state(struct page *page, enum zone_stat_item item)
362	{
363	mod_state(page_zone(page), item, 1, 1);
364	}
365	EXPORT_SYMBOL(inc_zone_page_state);
366
367	void dec_zone_page_state(struct page *page, enum zone_stat_item item)
368	{
369	mod_state(page_zone(page), item, -1, -1);
370	}
371	EXPORT_SYMBOL(dec_zone_page_state);
372	#else
373	/*
374	* Use interrupt disable to serialize counter updates
375	*/
376	void mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
377	int delta)
378	{
379	unsigned long flags;
380
381	local_irq_save(flags);
382	__mod_zone_page_state(zone, item, delta);
383	local_irq_restore(flags);
384	}
385	EXPORT_SYMBOL(mod_zone_page_state);
386
387	void inc_zone_state(struct zone *zone, enum zone_stat_item item)
388	{
389	unsigned long flags;
390
391	local_irq_save(flags);
392	__inc_zone_state(zone, item);
393	local_irq_restore(flags);
394	}
395
396	void inc_zone_page_state(struct page *page, enum zone_stat_item item)
397	{
398	unsigned long flags;
399	struct zone *zone;
400
401	zone = page_zone(page);
402	local_irq_save(flags);
403	__inc_zone_state(zone, item);
404	local_irq_restore(flags);
405	}
406	EXPORT_SYMBOL(inc_zone_page_state);
407
408	void dec_zone_page_state(struct page *page, enum zone_stat_item item)
409	{
410	unsigned long flags;
411
412	local_irq_save(flags);
413	__dec_zone_page_state(page, item);
414	local_irq_restore(flags);
415	}
416	EXPORT_SYMBOL(dec_zone_page_state);
417	#endif
418
419	/*
420	* Update the zone counters for one cpu.
421	*
422	* The cpu specified must be either the current cpu or a processor that
423	* is not online. If it is the current cpu then the execution thread must
424	* be pinned to the current cpu.
425	*
426	* Note that refresh_cpu_vm_stats strives to only access
427	* node local memory. The per cpu pagesets on remote zones are placed
428	* in the memory local to the processor using that pageset. So the
429	* loop over all zones will access a series of cachelines local to
430	* the processor.
431	*
432	* The call to zone_page_state_add updates the cachelines with the
433	* statistics in the remote zone struct as well as the global cachelines
434	* with the global counters. These could cause remote node cache line
435	* bouncing and will have to be only done when necessary.
436	*/
437	void refresh_cpu_vm_stats(int cpu)
438	{
439	struct zone *zone;
440	int i;
441	int global_diff[NR_VM_ZONE_STAT_ITEMS] = { 0, };
442
443	for_each_populated_zone(zone) {
444	struct per_cpu_pageset *p;
445
446	p = per_cpu_ptr(zone->pageset, cpu);
447
448	for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
449	if (p->vm_stat_diff[i]) {
450	unsigned long flags;
451	int v;
452
453	local_irq_save(flags);
454	v = p->vm_stat_diff[i];
455	p->vm_stat_diff[i] = 0;
456	local_irq_restore(flags);
457	atomic_long_add(v, &zone->vm_stat[i]);
458	global_diff[i] += v;
459	#ifdef CONFIG_NUMA
460	/* 3 seconds idle till flush */
461	p->expire = 3;
462	#endif
463	}
464	cond_resched();
465	#ifdef CONFIG_NUMA
466	/*
467	* Deal with draining the remote pageset of this
468	* processor
469	*
470	* Check if there are pages remaining in this pageset
471	* if not then there is nothing to expire.
472	*/
473	if (!p->expire \|\| !p->pcp.count)
474	continue;
475
476	/*
477	* We never drain zones local to this processor.
478	*/
479	if (zone_to_nid(zone) == numa_node_id()) {
480	p->expire = 0;
481	continue;
482	}
483
484	p->expire--;
485	if (p->expire)
486	continue;
487
488	if (p->pcp.count)
489	drain_zone_pages(zone, &p->pcp);
490	#endif
491	}
492
493	for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
494	if (global_diff[i])
495	atomic_long_add(global_diff[i], &vm_stat[i]);
496	}
497
498	#endif
499
500	#ifdef CONFIG_NUMA
501	/*
502	* zonelist = the list of zones passed to the allocator
503	* z = the zone from which the allocation occurred.
504	*
505	* Must be called with interrupts disabled.
506	*
507	* When __GFP_OTHER_NODE is set assume the node of the preferred
508	* zone is the local node. This is useful for daemons who allocate
509	* memory on behalf of other processes.
510	*/
511	void zone_statistics(struct zone preferred_zone, struct zone z, gfp_t flags)
512	{
513	if (z->zone_pgdat == preferred_zone->zone_pgdat) {
514	__inc_zone_state(z, NUMA_HIT);
515	} else {
516	__inc_zone_state(z, NUMA_MISS);
517	__inc_zone_state(preferred_zone, NUMA_FOREIGN);
518	}
519	if (z->node == ((flags & __GFP_OTHER_NODE) ?
520	preferred_zone->node : numa_node_id()))
521	__inc_zone_state(z, NUMA_LOCAL);
522	else
523	__inc_zone_state(z, NUMA_OTHER);
524	}
525	#endif
526
527	#ifdef CONFIG_COMPACTION
528
529	struct contig_page_info {
530	unsigned long free_pages;
531	unsigned long free_blocks_total;
532	unsigned long free_blocks_suitable;
533	};
534
535	/*
536	* Calculate the number of free pages in a zone, how many contiguous
537	* pages are free and how many are large enough to satisfy an allocation of
538	* the target size. Note that this function makes no attempt to estimate
539	* how many suitable free blocks there might be if MOVABLE pages were
540	* migrated. Calculating that is possible, but expensive and can be
541	* figured out from userspace
542	*/
543	static void fill_contig_page_info(struct zone *zone,
544	unsigned int suitable_order,
545	struct contig_page_info *info)
546	{
547	unsigned int order;
548
549	info->free_pages = 0;
550	info->free_blocks_total = 0;
551	info->free_blocks_suitable = 0;
552
553	for (order = 0; order < MAX_ORDER; order++) {
554	unsigned long blocks;
555
556	/* Count number of free blocks */
557	blocks = zone->free_area[order].nr_free;
558	info->free_blocks_total += blocks;
559
560	/* Count free base pages */
561	info->free_pages += blocks << order;
562
563	/* Count the suitable free blocks */
564	if (order >= suitable_order)
565	info->free_blocks_suitable += blocks <<
566	(order - suitable_order);
567	}
568	}
569
570	/*
571	* A fragmentation index only makes sense if an allocation of a requested
572	* size would fail. If that is true, the fragmentation index indicates
573	* whether external fragmentation or a lack of memory was the problem.
574	* The value can be used to determine if page reclaim or compaction
575	* should be used
576	*/
577	static int __fragmentation_index(unsigned int order, struct contig_page_info *info)
578	{
579	unsigned long requested = 1UL << order;
580
581	if (!info->free_blocks_total)
582	return 0;
583
584	/* Fragmentation index only makes sense when a request would fail */
585	if (info->free_blocks_suitable)
586	return -1000;
587
588	/*
589	* Index is between 0 and 1 so return within 3 decimal places
590	*
591	* 0 => allocation would fail due to lack of memory
592	* 1 => allocation would fail due to fragmentation
593	*/
594	return 1000 - div_u64( (1000+(div_u64(info->free_pages * 1000ULL, requested))), info->free_blocks_total);
595	}
596
597	/* Same as __fragmentation index but allocs contig_page_info on stack */
598	int fragmentation_index(struct zone *zone, unsigned int order)
599	{
600	struct contig_page_info info;
601
602	fill_contig_page_info(zone, order, &info);
603	return __fragmentation_index(order, &info);
604	}
605	#endif
606
607	#if defined(CONFIG_PROC_FS) \|\| defined(CONFIG_COMPACTION)
608	#include <linux/proc_fs.h>
609	#include <linux/seq_file.h>
610
611	static char * const migratetype_names[MIGRATE_TYPES] = {
612	"Unmovable",
613	"Reclaimable",
614	"Movable",
615	"Reserve",
616	#ifdef CONFIG_CMA
617	"CMA",
618	#endif
619	"Isolate",
620	};
621
622	static void frag_start(struct seq_file m, loff_t *pos)
623	{
624	pg_data_t *pgdat;
625	loff_t node = *pos;
626	for (pgdat = first_online_pgdat();
627	pgdat && node;
628	pgdat = next_online_pgdat(pgdat))
629	--node;
630
631	return pgdat;
632	}
633
634	static void frag_next(struct seq_file m, void arg, loff_t pos)
635	{
636	pg_data_t pgdat = (pg_data_t )arg;
637
638	(*pos)++;
639	return next_online_pgdat(pgdat);
640	}
641
642	static void frag_stop(struct seq_file m, void arg)
643	{
644	}
645
646	/* Walk all the zones in a node and print using a callback */
647	static void walk_zones_in_node(struct seq_file m, pg_data_t pgdat,
648	void (print)(struct seq_file m, pg_data_t , struct zone ))
649	{
650	struct zone *zone;
651	struct zone *node_zones = pgdat->node_zones;
652	unsigned long flags;
653
654	for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) {
655	if (!populated_zone(zone))
656	continue;
657
658	spin_lock_irqsave(&zone->lock, flags);
659	print(m, pgdat, zone);
660	spin_unlock_irqrestore(&zone->lock, flags);
661	}
662	}
663	#endif
664
665	#if defined(CONFIG_PROC_FS) \|\| defined(CONFIG_SYSFS) \|\| defined(CONFIG_NUMA)
666	#ifdef CONFIG_ZONE_DMA
667	#define TEXT_FOR_DMA(xx) xx "_dma",
668	#else
669	#define TEXT_FOR_DMA(xx)
670	#endif
671
672	#ifdef CONFIG_ZONE_DMA32
673	#define TEXT_FOR_DMA32(xx) xx "_dma32",
674	#else
675	#define TEXT_FOR_DMA32(xx)
676	#endif
677
678	#ifdef CONFIG_HIGHMEM
679	#define TEXT_FOR_HIGHMEM(xx) xx "_high",
680	#else
681	#define TEXT_FOR_HIGHMEM(xx)
682	#endif
683
684	#define TEXTS_FOR_ZONES(xx) TEXT_FOR_DMA(xx) TEXT_FOR_DMA32(xx) xx "_normal", \
685	TEXT_FOR_HIGHMEM(xx) xx "_movable",
686
687	const char * const vmstat_text[] = {
688	/* Zoned VM counters */
689	"nr_free_pages",
690	"nr_inactive_anon",
691	"nr_active_anon",
692	"nr_inactive_file",
693	"nr_active_file",
694	"nr_unevictable",
695	"nr_mlock",
696	"nr_anon_pages",
697	"nr_mapped",
698	"nr_file_pages",
699	"nr_dirty",
700	"nr_writeback",
701	"nr_slab_reclaimable",
702	"nr_slab_unreclaimable",
703	"nr_page_table_pages",
704	"nr_kernel_stack",
705	"nr_unstable",
706	"nr_bounce",
707	"nr_vmscan_write",
708	"nr_vmscan_immediate_reclaim",
709	"nr_writeback_temp",
710	"nr_isolated_anon",
711	"nr_isolated_file",
712	"nr_shmem",
713	"nr_dirtied",
714	"nr_written",
715
716	#ifdef CONFIG_NUMA
717	"numa_hit",
718	"numa_miss",
719	"numa_foreign",
720	"numa_interleave",
721	"numa_local",
722	"numa_other",
723	#endif
724	"nr_anon_transparent_hugepages",
725	"nr_dirty_threshold",
726	"nr_dirty_background_threshold",
727
728	#ifdef CONFIG_VM_EVENT_COUNTERS
729	"pgpgin",
730	"pgpgout",
731	"pswpin",
732	"pswpout",
733
734	TEXTS_FOR_ZONES("pgalloc")
735
736	"pgfree",
737	"pgactivate",
738	"pgdeactivate",
739
740	"pgfault",
741	"pgmajfault",
742
743	TEXTS_FOR_ZONES("pgrefill")
744	TEXTS_FOR_ZONES("pgsteal_kswapd")
745	TEXTS_FOR_ZONES("pgsteal_direct")
746	TEXTS_FOR_ZONES("pgscan_kswapd")
747	TEXTS_FOR_ZONES("pgscan_direct")
748	"pgscan_direct_throttle",
749
750	#ifdef CONFIG_NUMA
751	"zone_reclaim_failed",
752	#endif
753	"pginodesteal",
754	"slabs_scanned",
755	"kswapd_inodesteal",
756	"kswapd_low_wmark_hit_quickly",
757	"kswapd_high_wmark_hit_quickly",
758	"kswapd_skip_congestion_wait",
759	"pageoutrun",
760	"allocstall",
761
762	"pgrotated",
763
764	#ifdef CONFIG_COMPACTION
765	"compact_blocks_moved",
766	"compact_pages_moved",
767	"compact_pagemigrate_failed",
768	"compact_stall",
769	"compact_fail",
770	"compact_success",
771	#endif
772
773	#ifdef CONFIG_HUGETLB_PAGE
774	"htlb_buddy_alloc_success",
775	"htlb_buddy_alloc_fail",
776	#endif
777	"unevictable_pgs_culled",
778	"unevictable_pgs_scanned",
779	"unevictable_pgs_rescued",
780	"unevictable_pgs_mlocked",
781	"unevictable_pgs_munlocked",
782	"unevictable_pgs_cleared",
783	"unevictable_pgs_stranded",
784	"unevictable_pgs_mlockfreed",
785
786	#ifdef CONFIG_TRANSPARENT_HUGEPAGE
787	"thp_fault_alloc",
788	"thp_fault_fallback",
789	"thp_collapse_alloc",
790	"thp_collapse_alloc_failed",
791	"thp_split",
792	#endif
793
794	#endif /* CONFIG_VM_EVENTS_COUNTERS */
795	};
796	#endif /* CONFIG_PROC_FS \|\| CONFIG_SYSFS \|\| CONFIG_NUMA */
797
798
799	#ifdef CONFIG_PROC_FS
800	static void frag_show_print(struct seq_file m, pg_data_t pgdat,
801	struct zone *zone)
802	{
803	int order;
804
805	seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name);
806	for (order = 0; order < MAX_ORDER; ++order)
807	seq_printf(m, "%6lu ", zone->free_area[order].nr_free);
808	seq_putc(m, '\n');
809	}
810
811	/*
812	* This walks the free areas for each zone.
813	*/
814	static int frag_show(struct seq_file m, void arg)
815	{
816	pg_data_t pgdat = (pg_data_t )arg;
817	walk_zones_in_node(m, pgdat, frag_show_print);
818	return 0;
819	}
820
821	static void pagetypeinfo_showfree_print(struct seq_file *m,
822	pg_data_t pgdat, struct zone zone)
823	{
824	int order, mtype;
825
826	for (mtype = 0; mtype < MIGRATE_TYPES; mtype++) {
827	seq_printf(m, "Node %4d, zone %8s, type %12s ",
828	pgdat->node_id,
829	zone->name,
830	migratetype_names[mtype]);
831	for (order = 0; order < MAX_ORDER; ++order) {
832	unsigned long freecount = 0;
833	struct free_area *area;
834	struct list_head *curr;
835
836	area = &(zone->free_area[order]);
837
838	list_for_each(curr, &area->free_list[mtype])
839	freecount++;
840	seq_printf(m, "%6lu ", freecount);
841	}
842	seq_putc(m, '\n');
843	}
844	}
845
846	/* Print out the free pages at each order for each migatetype */
847	static int pagetypeinfo_showfree(struct seq_file m, void arg)
848	{
849	int order;
850	pg_data_t pgdat = (pg_data_t )arg;
851
852	/* Print header */
853	seq_printf(m, "%-43s ", "Free pages count per migrate type at order");
854	for (order = 0; order < MAX_ORDER; ++order)
855	seq_printf(m, "%6d ", order);
856	seq_putc(m, '\n');
857
858	walk_zones_in_node(m, pgdat, pagetypeinfo_showfree_print);
859
860	return 0;
861	}
862
863	static void pagetypeinfo_showblockcount_print(struct seq_file *m,
864	pg_data_t pgdat, struct zone zone)
865	{
866	int mtype;
867	unsigned long pfn;
868	unsigned long start_pfn = zone->zone_start_pfn;
869	unsigned long end_pfn = start_pfn + zone->spanned_pages;
870	unsigned long count[MIGRATE_TYPES] = { 0, };
871
872	for (pfn = start_pfn; pfn < end_pfn; pfn += pageblock_nr_pages) {
873	struct page *page;
874
875	if (!pfn_valid(pfn))
876	continue;
877
878	page = pfn_to_page(pfn);
879
880	/* Watch for unexpected holes punched in the memmap */
881	if (!memmap_valid_within(pfn, page, zone))
882	continue;
883
884	mtype = get_pageblock_migratetype(page);
885
886	if (mtype < MIGRATE_TYPES)
887	count[mtype]++;
888	}
889
890	/* Print counts */
891	seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name);
892	for (mtype = 0; mtype < MIGRATE_TYPES; mtype++)
893	seq_printf(m, "%12lu ", count[mtype]);
894	seq_putc(m, '\n');
895	}
896
897	/* Print out the free pages at each order for each migratetype */
898	static int pagetypeinfo_showblockcount(struct seq_file m, void arg)
899	{
900	int mtype;
901	pg_data_t pgdat = (pg_data_t )arg;
902
903	seq_printf(m, "\n%-23s", "Number of blocks type ");
904	for (mtype = 0; mtype < MIGRATE_TYPES; mtype++)
905	seq_printf(m, "%12s ", migratetype_names[mtype]);
906	seq_putc(m, '\n');
907	walk_zones_in_node(m, pgdat, pagetypeinfo_showblockcount_print);
908
909	return 0;
910	}
911
912	/*
913	* This prints out statistics in relation to grouping pages by mobility.
914	* It is expensive to collect so do not constantly read the file.
915	*/
916	static int pagetypeinfo_show(struct seq_file m, void arg)
917	{
918	pg_data_t pgdat = (pg_data_t )arg;
919
920	/* check memoryless node */
921	if (!node_state(pgdat->node_id, N_HIGH_MEMORY))
922	return 0;
923
924	seq_printf(m, "Page block order: %d\n", pageblock_order);
925	seq_printf(m, "Pages per block: %lu\n", pageblock_nr_pages);
926	seq_putc(m, '\n');
927	pagetypeinfo_showfree(m, pgdat);
928	pagetypeinfo_showblockcount(m, pgdat);
929
930	return 0;
931	}
932
933	static const struct seq_operations fragmentation_op = {
934	.start = frag_start,
935	.next = frag_next,
936	.stop = frag_stop,
937	.show = frag_show,
938	};
939
940	static int fragmentation_open(struct inode inode, struct file file)
941	{
942	return seq_open(file, &fragmentation_op);
943	}
944
945	static const struct file_operations fragmentation_file_operations = {
946	.open = fragmentation_open,
947	.read = seq_read,
948	.llseek = seq_lseek,
949	.release = seq_release,
950	};
951
952	static const struct seq_operations pagetypeinfo_op = {
953	.start = frag_start,
954	.next = frag_next,
955	.stop = frag_stop,
956	.show = pagetypeinfo_show,
957	};
958
959	static int pagetypeinfo_open(struct inode inode, struct file file)
960	{
961	return seq_open(file, &pagetypeinfo_op);
962	}
963
964	static const struct file_operations pagetypeinfo_file_ops = {
965	.open = pagetypeinfo_open,
966	.read = seq_read,
967	.llseek = seq_lseek,
968	.release = seq_release,
969	};
970
971	static void zoneinfo_show_print(struct seq_file m, pg_data_t pgdat,
972	struct zone *zone)
973	{
974	int i;
975	seq_printf(m, "Node %d, zone %8s", pgdat->node_id, zone->name);
976	seq_printf(m,
977	"\n pages free %lu"
978	"\n min %lu"
979	"\n low %lu"
980	"\n high %lu"
981	"\n scanned %lu"
982	"\n spanned %lu"
983	"\n present %lu",
984	zone_page_state(zone, NR_FREE_PAGES),
985	min_wmark_pages(zone),
986	low_wmark_pages(zone),
987	high_wmark_pages(zone),
988	zone->pages_scanned,
989	zone->spanned_pages,
990	zone->present_pages);
991
992	for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
993	seq_printf(m, "\n %-12s %lu", vmstat_text[i],
994	zone_page_state(zone, i));
995
996	seq_printf(m,
997	"\n protection: (%lu",
998	zone->lowmem_reserve[0]);
999	for (i = 1; i < ARRAY_SIZE(zone->lowmem_reserve); i++)
1000	seq_printf(m, ", %lu", zone->lowmem_reserve[i]);
1001	seq_printf(m,
1002	")"
1003	"\n pagesets");
1004	for_each_online_cpu(i) {
1005	struct per_cpu_pageset *pageset;
1006
1007	pageset = per_cpu_ptr(zone->pageset, i);
1008	seq_printf(m,
1009	"\n cpu: %i"
1010	"\n count: %i"
1011	"\n high: %i"
1012	"\n batch: %i",
1013	i,
1014	pageset->pcp.count,
1015	pageset->pcp.high,
1016	pageset->pcp.batch);
1017	#ifdef CONFIG_SMP
1018	seq_printf(m, "\n vm stats threshold: %d",
1019	pageset->stat_threshold);
1020	#endif
1021	}
1022	seq_printf(m,
1023	"\n all_unreclaimable: %u"
1024	"\n start_pfn: %lu"
1025	"\n inactive_ratio: %u",
1026	zone->all_unreclaimable,
1027	zone->zone_start_pfn,
1028	zone->inactive_ratio);
1029	seq_putc(m, '\n');
1030	}
1031
1032	/*
1033	* Output information about zones in @pgdat.
1034	*/
1035	static int zoneinfo_show(struct seq_file m, void arg)
1036	{
1037	pg_data_t pgdat = (pg_data_t )arg;
1038	walk_zones_in_node(m, pgdat, zoneinfo_show_print);
1039	return 0;
1040	}
1041
1042	static const struct seq_operations zoneinfo_op = {
1043	.start = frag_start, /* iterate over all zones. The same as in
1044	* fragmentation. */
1045	.next = frag_next,
1046	.stop = frag_stop,
1047	.show = zoneinfo_show,
1048	};
1049
1050	static int zoneinfo_open(struct inode inode, struct file file)
1051	{
1052	return seq_open(file, &zoneinfo_op);
1053	}
1054
1055	static const struct file_operations proc_zoneinfo_file_operations = {
1056	.open = zoneinfo_open,
1057	.read = seq_read,
1058	.llseek = seq_lseek,
1059	.release = seq_release,
1060	};
1061
1062	enum writeback_stat_item {
1063	NR_DIRTY_THRESHOLD,
1064	NR_DIRTY_BG_THRESHOLD,
1065	NR_VM_WRITEBACK_STAT_ITEMS,
1066	};
1067
1068	static void vmstat_start(struct seq_file m, loff_t *pos)
1069	{
1070	unsigned long *v;
1071	int i, stat_items_size;
1072
1073	if (*pos >= ARRAY_SIZE(vmstat_text))
1074	return NULL;
1075	stat_items_size = NR_VM_ZONE_STAT_ITEMS * sizeof(unsigned long) +
1076	NR_VM_WRITEBACK_STAT_ITEMS * sizeof(unsigned long);
1077
1078	#ifdef CONFIG_VM_EVENT_COUNTERS
1079	stat_items_size += sizeof(struct vm_event_state);
1080	#endif
1081
1082	v = kmalloc(stat_items_size, GFP_KERNEL);
1083	m->private = v;
1084	if (!v)
1085	return ERR_PTR(-ENOMEM);
1086	for (i = 0; i < NR_VM_ZONE_STAT_ITEMS; i++)
1087	v[i] = global_page_state(i);
1088	v += NR_VM_ZONE_STAT_ITEMS;
1089
1090	global_dirty_limits(v + NR_DIRTY_BG_THRESHOLD,
1091	v + NR_DIRTY_THRESHOLD);
1092	v += NR_VM_WRITEBACK_STAT_ITEMS;
1093
1094	#ifdef CONFIG_VM_EVENT_COUNTERS
1095	all_vm_events(v);
1096	v[PGPGIN] /= 2; /* sectors -> kbytes */
1097	v[PGPGOUT] /= 2;
1098	#endif
1099	return (unsigned long )m->private + pos;
1100	}
1101
1102	static void vmstat_next(struct seq_file m, void arg, loff_t pos)
1103	{
1104	(*pos)++;
1105	if (*pos >= ARRAY_SIZE(vmstat_text))
1106	return NULL;
1107	return (unsigned long )m->private + pos;
1108	}
1109
1110	static int vmstat_show(struct seq_file m, void arg)
1111	{
1112	unsigned long *l = arg;
1113	unsigned long off = l - (unsigned long *)m->private;
1114
1115	seq_printf(m, "%s %lu\n", vmstat_text[off], *l);
1116	return 0;
1117	}
1118
1119	static void vmstat_stop(struct seq_file m, void arg)
1120	{
1121	kfree(m->private);
1122	m->private = NULL;
1123	}
1124
1125	static const struct seq_operations vmstat_op = {
1126	.start = vmstat_start,
1127	.next = vmstat_next,
1128	.stop = vmstat_stop,
1129	.show = vmstat_show,
1130	};
1131
1132	static int vmstat_open(struct inode inode, struct file file)
1133	{
1134	return seq_open(file, &vmstat_op);
1135	}
1136
1137	static const struct file_operations proc_vmstat_file_operations = {
1138	.open = vmstat_open,
1139	.read = seq_read,
1140	.llseek = seq_lseek,
1141	.release = seq_release,
1142	};
1143	#endif /* CONFIG_PROC_FS */
1144
1145	#ifdef CONFIG_SMP
1146	static DEFINE_PER_CPU(struct delayed_work, vmstat_work);
1147	int sysctl_stat_interval __read_mostly = HZ;
1148
1149	static void vmstat_update(struct work_struct *w)
1150	{
1151	refresh_cpu_vm_stats(smp_processor_id());
1152	schedule_delayed_work(&__get_cpu_var(vmstat_work),
1153	round_jiffies_relative(sysctl_stat_interval));
1154	}
1155
1156	static void __cpuinit start_cpu_timer(int cpu)
1157	{
1158	struct delayed_work *work = &per_cpu(vmstat_work, cpu);
1159
1160	INIT_DELAYED_WORK_DEFERRABLE(work, vmstat_update);
1161	schedule_delayed_work_on(cpu, work, __round_jiffies_relative(HZ, cpu));
1162	}
1163
1164	/*
1165	* Use the cpu notifier to insure that the thresholds are recalculated
1166	* when necessary.
1167	*/
1168	static int __cpuinit vmstat_cpuup_callback(struct notifier_block *nfb,
1169	unsigned long action,
1170	void *hcpu)
1171	{
1172	long cpu = (long)hcpu;
1173
1174	switch (action) {
1175	case CPU_ONLINE:
1176	case CPU_ONLINE_FROZEN:
1177	refresh_zone_stat_thresholds();
1178	start_cpu_timer(cpu);
1179	node_set_state(cpu_to_node(cpu), N_CPU);
1180	break;
1181	case CPU_DOWN_PREPARE:
1182	case CPU_DOWN_PREPARE_FROZEN:
1183	cancel_delayed_work_sync(&per_cpu(vmstat_work, cpu));
1184	per_cpu(vmstat_work, cpu).work.func = NULL;
1185	break;
1186	case CPU_DOWN_FAILED:
1187	case CPU_DOWN_FAILED_FROZEN:
1188	start_cpu_timer(cpu);
1189	break;
1190	case CPU_DEAD:
1191	case CPU_DEAD_FROZEN:
1192	refresh_zone_stat_thresholds();
1193	break;
1194	default:
1195	break;
1196	}
1197	return NOTIFY_OK;
1198	}
1199
1200	static struct notifier_block __cpuinitdata vmstat_notifier =
1201	{ &vmstat_cpuup_callback, NULL, 0 };
1202	#endif
1203
1204	static int __init setup_vmstat(void)
1205	{
1206	#ifdef CONFIG_SMP
1207	int cpu;
1208
1209	register_cpu_notifier(&vmstat_notifier);
1210
1211	for_each_online_cpu(cpu)
1212	start_cpu_timer(cpu);
1213	#endif
1214	#ifdef CONFIG_PROC_FS
1215	proc_create("buddyinfo", S_IRUGO, NULL, &fragmentation_file_operations);
1216	proc_create("pagetypeinfo", S_IRUGO, NULL, &pagetypeinfo_file_ops);
1217	proc_create("vmstat", S_IRUGO, NULL, &proc_vmstat_file_operations);
1218	proc_create("zoneinfo", S_IRUGO, NULL, &proc_zoneinfo_file_operations);
1219	#endif
1220	return 0;
1221	}
1222	module_init(setup_vmstat)
1223
1224	#if defined(CONFIG_DEBUG_FS) && defined(CONFIG_COMPACTION)
1225	#include <linux/debugfs.h>
1226
1227
1228	/*
1229	* Return an index indicating how much of the available free memory is
1230	* unusable for an allocation of the requested size.
1231	*/
1232	static int unusable_free_index(unsigned int order,
1233	struct contig_page_info *info)
1234	{
1235	/* No free memory is interpreted as all free memory is unusable */
1236	if (info->free_pages == 0)
1237	return 1000;
1238
1239	/*
1240	* Index should be a value between 0 and 1. Return a value to 3
1241	* decimal places.
1242	*
1243	* 0 => no fragmentation
1244	* 1 => high fragmentation
1245	*/
1246	return div_u64((info->free_pages - (info->free_blocks_suitable << order)) * 1000ULL, info->free_pages);
1247
1248	}
1249
1250	static void unusable_show_print(struct seq_file *m,
1251	pg_data_t pgdat, struct zone zone)
1252	{
1253	unsigned int order;
1254	int index;
1255	struct contig_page_info info;
1256
1257	seq_printf(m, "Node %d, zone %8s ",
1258	pgdat->node_id,
1259	zone->name);
1260	for (order = 0; order < MAX_ORDER; ++order) {
1261	fill_contig_page_info(zone, order, &info);
1262	index = unusable_free_index(order, &info);
1263	seq_printf(m, "%d.%03d ", index / 1000, index % 1000);
1264	}
1265
1266	seq_putc(m, '\n');
1267	}
1268
1269	/*
1270	* Display unusable free space index
1271	*
1272	* The unusable free space index measures how much of the available free
1273	* memory cannot be used to satisfy an allocation of a given size and is a
1274	* value between 0 and 1. The higher the value, the more of free memory is
1275	* unusable and by implication, the worse the external fragmentation is. This
1276	* can be expressed as a percentage by multiplying by 100.
1277	*/
1278	static int unusable_show(struct seq_file m, void arg)
1279	{
1280	pg_data_t pgdat = (pg_data_t )arg;
1281
1282	/* check memoryless node */
1283	if (!node_state(pgdat->node_id, N_HIGH_MEMORY))
1284	return 0;
1285
1286	walk_zones_in_node(m, pgdat, unusable_show_print);
1287
1288	return 0;
1289	}
1290
1291	static const struct seq_operations unusable_op = {
1292	.start = frag_start,
1293	.next = frag_next,
1294	.stop = frag_stop,
1295	.show = unusable_show,
1296	};
1297
1298	static int unusable_open(struct inode inode, struct file file)
1299	{
1300	return seq_open(file, &unusable_op);
1301	}
1302
1303	static const struct file_operations unusable_file_ops = {
1304	.open = unusable_open,
1305	.read = seq_read,
1306	.llseek = seq_lseek,
1307	.release = seq_release,
1308	};
1309
1310	static void extfrag_show_print(struct seq_file *m,
1311	pg_data_t pgdat, struct zone zone)
1312	{
1313	unsigned int order;
1314	int index;
1315
1316	/* Alloc on stack as interrupts are disabled for zone walk */
1317	struct contig_page_info info;
1318
1319	seq_printf(m, "Node %d, zone %8s ",
1320	pgdat->node_id,
1321	zone->name);
1322	for (order = 0; order < MAX_ORDER; ++order) {
1323	fill_contig_page_info(zone, order, &info);
1324	index = __fragmentation_index(order, &info);
1325	seq_printf(m, "%d.%03d ", index / 1000, index % 1000);
1326	}
1327
1328	seq_putc(m, '\n');
1329	}
1330
1331	/*
1332	* Display fragmentation index for orders that allocations would fail for
1333	*/
1334	static int extfrag_show(struct seq_file m, void arg)
1335	{
1336	pg_data_t pgdat = (pg_data_t )arg;
1337
1338	walk_zones_in_node(m, pgdat, extfrag_show_print);
1339
1340	return 0;
1341	}
1342
1343	static const struct seq_operations extfrag_op = {
1344	.start = frag_start,
1345	.next = frag_next,
1346	.stop = frag_stop,
1347	.show = extfrag_show,
1348	};
1349
1350	static int extfrag_open(struct inode inode, struct file file)
1351	{
1352	return seq_open(file, &extfrag_op);
1353	}
1354
1355	static const struct file_operations extfrag_file_ops = {
1356	.open = extfrag_open,
1357	.read = seq_read,
1358	.llseek = seq_lseek,
1359	.release = seq_release,
1360	};
1361
1362	static int __init extfrag_debug_init(void)
1363	{
1364	struct dentry *extfrag_debug_root;
1365
1366	extfrag_debug_root = debugfs_create_dir("extfrag", NULL);
1367	if (!extfrag_debug_root)
1368	return -ENOMEM;
1369
1370	if (!debugfs_create_file("unusable_index", 0444,
1371	extfrag_debug_root, NULL, &unusable_file_ops))
1372	goto fail;
1373
1374	if (!debugfs_create_file("extfrag_index", 0444,
1375	extfrag_debug_root, NULL, &extfrag_file_ops))
1376	goto fail;
1377
1378	return 0;
1379	fail:
1380	debugfs_remove_recursive(extfrag_debug_root);
1381	return -ENOMEM;
1382	}
1383
1384	module_init(extfrag_debug_init);
1385	#endif
1386

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/mm/vmstat.c

interactive