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

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