[linux.git] / mm / vmstat.c

/*
 *  linux/mm/vmstat.c
 *
 *  Manages VM statistics
 *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
 */

#include <linux/config.h>
#include <linux/mm.h>

/*
 * Accumulate the page_state information across all CPUs.
 * The result is unavoidably approximate - it can change
 * during and after execution of this function.
 */
DEFINE_PER_CPU(struct page_state, page_states) = {0};

atomic_t nr_pagecache = ATOMIC_INIT(0);
EXPORT_SYMBOL(nr_pagecache);
#ifdef CONFIG_SMP
DEFINE_PER_CPU(long, nr_pagecache_local) = 0;
#endif

static void __get_page_state(struct page_state *ret, int nr, cpumask_t *cpumask)
{
	unsigned cpu;

	memset(ret, 0, nr * sizeof(unsigned long));
	cpus_and(*cpumask, *cpumask, cpu_online_map);

	for_each_cpu_mask(cpu, *cpumask) {
		unsigned long *in;
		unsigned long *out;
		unsigned off;
		unsigned next_cpu;

		in = (unsigned long *)&per_cpu(page_states, cpu);

		next_cpu = next_cpu(cpu, *cpumask);
		if (likely(next_cpu < NR_CPUS))
			prefetch(&per_cpu(page_states, next_cpu));

		out = (unsigned long *)ret;
		for (off = 0; off < nr; off++)
			*out++ += *in++;
	}
}

void get_page_state_node(struct page_state *ret, int node)
{
	int nr;
	cpumask_t mask = node_to_cpumask(node);

	nr = offsetof(struct page_state, GET_PAGE_STATE_LAST);
	nr /= sizeof(unsigned long);

	__get_page_state(ret, nr+1, &mask);
}

void get_page_state(struct page_state *ret)
{
	int nr;
	cpumask_t mask = CPU_MASK_ALL;

	nr = offsetof(struct page_state, GET_PAGE_STATE_LAST);
	nr /= sizeof(unsigned long);

	__get_page_state(ret, nr + 1, &mask);
}

void get_full_page_state(struct page_state *ret)
{
	cpumask_t mask = CPU_MASK_ALL;

	__get_page_state(ret, sizeof(*ret) / sizeof(unsigned long), &mask);
}

unsigned long read_page_state_offset(unsigned long offset)
{
	unsigned long ret = 0;
	int cpu;

	for_each_online_cpu(cpu) {
		unsigned long in;

		in = (unsigned long)&per_cpu(page_states, cpu) + offset;
		ret += *((unsigned long *)in);
	}
	return ret;
}

void __mod_page_state_offset(unsigned long offset, unsigned long delta)
{
	void *ptr;

	ptr = &__get_cpu_var(page_states);
	*(unsigned long *)(ptr + offset) += delta;
}
EXPORT_SYMBOL(__mod_page_state_offset);

void mod_page_state_offset(unsigned long offset, unsigned long delta)
{
	unsigned long flags;
	void *ptr;

	local_irq_save(flags);
	ptr = &__get_cpu_var(page_states);
	*(unsigned long *)(ptr + offset) += delta;
	local_irq_restore(flags);
}
EXPORT_SYMBOL(mod_page_state_offset);

void __get_zone_counts(unsigned long *active, unsigned long *inactive,
			unsigned long *free, struct pglist_data *pgdat)
{
	struct zone *zones = pgdat->node_zones;
	int i;

	*active = 0;
	*inactive = 0;
	*free = 0;
	for (i = 0; i < MAX_NR_ZONES; i++) {
		*active += zones[i].nr_active;
		*inactive += zones[i].nr_inactive;
		*free += zones[i].free_pages;
	}
}

void get_zone_counts(unsigned long *active,
		unsigned long *inactive, unsigned long *free)
{
	struct pglist_data *pgdat;

	*active = 0;
	*inactive = 0;
	*free = 0;
	for_each_online_pgdat(pgdat) {
		unsigned long l, m, n;
		__get_zone_counts(&l, &m, &n, pgdat);
		*active += l;
		*inactive += m;
		*free += n;
	}
}

#ifdef CONFIG_PROC_FS

#include <linux/seq_file.h>

static void *frag_start(struct seq_file *m, loff_t *pos)
{
	pg_data_t *pgdat;
	loff_t node = *pos;
	for (pgdat = first_online_pgdat();
	     pgdat && node;
	     pgdat = next_online_pgdat(pgdat))
		--node;

	return pgdat;
}

static void *frag_next(struct seq_file *m, void *arg, loff_t *pos)
{
	pg_data_t *pgdat = (pg_data_t *)arg;

	(*pos)++;
	return next_online_pgdat(pgdat);
}

static void frag_stop(struct seq_file *m, void *arg)
{
}

/*
 * This walks the free areas for each zone.
 */
static int frag_show(struct seq_file *m, void *arg)
{
	pg_data_t *pgdat = (pg_data_t *)arg;
	struct zone *zone;
	struct zone *node_zones = pgdat->node_zones;
	unsigned long flags;
	int order;

	for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) {
		if (!populated_zone(zone))
			continue;

		spin_lock_irqsave(&zone->lock, flags);
		seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name);
		for (order = 0; order < MAX_ORDER; ++order)
			seq_printf(m, "%6lu ", zone->free_area[order].nr_free);
		spin_unlock_irqrestore(&zone->lock, flags);
		seq_putc(m, '\n');
	}
	return 0;
}

struct seq_operations fragmentation_op = {
	.start	= frag_start,
	.next	= frag_next,
	.stop	= frag_stop,
	.show	= frag_show,
};

static char *vmstat_text[] = {
	"nr_dirty",
	"nr_writeback",
	"nr_unstable",
	"nr_page_table_pages",
	"nr_mapped",
	"nr_slab",

	"pgpgin",
	"pgpgout",
	"pswpin",
	"pswpout",

	"pgalloc_high",
	"pgalloc_normal",
	"pgalloc_dma32",
	"pgalloc_dma",

	"pgfree",
	"pgactivate",
	"pgdeactivate",

	"pgfault",
	"pgmajfault",

	"pgrefill_high",
	"pgrefill_normal",
	"pgrefill_dma32",
	"pgrefill_dma",

	"pgsteal_high",
	"pgsteal_normal",
	"pgsteal_dma32",
	"pgsteal_dma",

	"pgscan_kswapd_high",
	"pgscan_kswapd_normal",
	"pgscan_kswapd_dma32",
	"pgscan_kswapd_dma",

	"pgscan_direct_high",
	"pgscan_direct_normal",
	"pgscan_direct_dma32",
	"pgscan_direct_dma",

	"pginodesteal",
	"slabs_scanned",
	"kswapd_steal",
	"kswapd_inodesteal",
	"pageoutrun",
	"allocstall",

	"pgrotated",
	"nr_bounce",
};

/*
 * Output information about zones in @pgdat.
 */
static int zoneinfo_show(struct seq_file *m, void *arg)
{
	pg_data_t *pgdat = arg;
	struct zone *zone;
	struct zone *node_zones = pgdat->node_zones;
	unsigned long flags;

	for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; zone++) {
		int i;

		if (!populated_zone(zone))
			continue;

		spin_lock_irqsave(&zone->lock, flags);
		seq_printf(m, "Node %d, zone %8s", pgdat->node_id, zone->name);
		seq_printf(m,
			   "\n  pages free     %lu"
			   "\n        min      %lu"
			   "\n        low      %lu"
			   "\n        high     %lu"
			   "\n        active   %lu"
			   "\n        inactive %lu"
			   "\n        scanned  %lu (a: %lu i: %lu)"
			   "\n        spanned  %lu"
			   "\n        present  %lu",
			   zone->free_pages,
			   zone->pages_min,
			   zone->pages_low,
			   zone->pages_high,
			   zone->nr_active,
			   zone->nr_inactive,
			   zone->pages_scanned,
			   zone->nr_scan_active, zone->nr_scan_inactive,
			   zone->spanned_pages,
			   zone->present_pages);
		seq_printf(m,
			   "\n        protection: (%lu",
			   zone->lowmem_reserve[0]);
		for (i = 1; i < ARRAY_SIZE(zone->lowmem_reserve); i++)
			seq_printf(m, ", %lu", zone->lowmem_reserve[i]);
		seq_printf(m,
			   ")"
			   "\n  pagesets");
		for_each_online_cpu(i) {
			struct per_cpu_pageset *pageset;
			int j;

			pageset = zone_pcp(zone, i);
			for (j = 0; j < ARRAY_SIZE(pageset->pcp); j++) {
				if (pageset->pcp[j].count)
					break;
			}
			if (j == ARRAY_SIZE(pageset->pcp))
				continue;
			for (j = 0; j < ARRAY_SIZE(pageset->pcp); j++) {
				seq_printf(m,
					   "\n    cpu: %i pcp: %i"
					   "\n              count: %i"
					   "\n              high:  %i"
					   "\n              batch: %i",
					   i, j,
					   pageset->pcp[j].count,
					   pageset->pcp[j].high,
					   pageset->pcp[j].batch);
			}
#ifdef CONFIG_NUMA
			seq_printf(m,
				   "\n            numa_hit:       %lu"
				   "\n            numa_miss:      %lu"
				   "\n            numa_foreign:   %lu"
				   "\n            interleave_hit: %lu"
				   "\n            local_node:     %lu"
				   "\n            other_node:     %lu",
				   pageset->numa_hit,
				   pageset->numa_miss,
				   pageset->numa_foreign,
				   pageset->interleave_hit,
				   pageset->local_node,
				   pageset->other_node);
#endif
		}
		seq_printf(m,
			   "\n  all_unreclaimable: %u"
			   "\n  prev_priority:     %i"
			   "\n  temp_priority:     %i"
			   "\n  start_pfn:         %lu",
			   zone->all_unreclaimable,
			   zone->prev_priority,
			   zone->temp_priority,
			   zone->zone_start_pfn);
		spin_unlock_irqrestore(&zone->lock, flags);
		seq_putc(m, '\n');
	}
	return 0;
}

struct seq_operations zoneinfo_op = {
	.start	= frag_start, /* iterate over all zones. The same as in
			       * fragmentation. */
	.next	= frag_next,
	.stop	= frag_stop,
	.show	= zoneinfo_show,
};

static void *vmstat_start(struct seq_file *m, loff_t *pos)
{
	struct page_state *ps;

	if (*pos >= ARRAY_SIZE(vmstat_text))
		return NULL;

	ps = kmalloc(sizeof(*ps), GFP_KERNEL);
	m->private = ps;
	if (!ps)
		return ERR_PTR(-ENOMEM);
	get_full_page_state(ps);
	ps->pgpgin /= 2;		/* sectors -> kbytes */
	ps->pgpgout /= 2;
	return (unsigned long *)ps + *pos;
}

static void *vmstat_next(struct seq_file *m, void *arg, loff_t *pos)
{
	(*pos)++;
	if (*pos >= ARRAY_SIZE(vmstat_text))
		return NULL;
	return (unsigned long *)m->private + *pos;
}

static int vmstat_show(struct seq_file *m, void *arg)
{
	unsigned long *l = arg;
	unsigned long off = l - (unsigned long *)m->private;

	seq_printf(m, "%s %lu\n", vmstat_text[off], *l);
	return 0;
}

static void vmstat_stop(struct seq_file *m, void *arg)
{
	kfree(m->private);
	m->private = NULL;
}

struct seq_operations vmstat_op = {
	.start	= vmstat_start,
	.next	= vmstat_next,
	.stop	= vmstat_stop,
	.show	= vmstat_show,
};

#endif /* CONFIG_PROC_FS */
Commit	Line	Data
f6ac2354 CL	1	/*
	2	* linux/mm/vmstat.c
	3	*
	4	* Manages VM statistics
	5	* Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
	6	*/
	7
	8	#include <linux/config.h>
	9	#include <linux/mm.h>
	10
	11	/*
	12	* Accumulate the page_state information across all CPUs.
	13	* The result is unavoidably approximate - it can change
	14	* during and after execution of this function.
	15	*/
	16	DEFINE_PER_CPU(struct page_state, page_states) = {0};
	17
	18	atomic_t nr_pagecache = ATOMIC_INIT(0);
	19	EXPORT_SYMBOL(nr_pagecache);
	20	#ifdef CONFIG_SMP
	21	DEFINE_PER_CPU(long, nr_pagecache_local) = 0;
	22	#endif
	23
	24	static void __get_page_state(struct page_state ret, int nr, cpumask_t cpumask)
	25	{
	26	unsigned cpu;
	27
	28	memset(ret, 0, nr * sizeof(unsigned long));
	29	cpus_and(cpumask, cpumask, cpu_online_map);
	30
	31	for_each_cpu_mask(cpu, *cpumask) {
	32	unsigned long *in;
	33	unsigned long *out;
	34	unsigned off;
	35	unsigned next_cpu;
	36
	37	in = (unsigned long *)&per_cpu(page_states, cpu);
	38
	39	next_cpu = next_cpu(cpu, *cpumask);
	40	if (likely(next_cpu < NR_CPUS))
	41	prefetch(&per_cpu(page_states, next_cpu));
	42
	43	out = (unsigned long *)ret;
	44	for (off = 0; off < nr; off++)
	45	out++ += in++;
	46	}
	47	}
	48
	49	void get_page_state_node(struct page_state *ret, int node)
	50	{
	51	int nr;
	52	cpumask_t mask = node_to_cpumask(node);
	53
	54	nr = offsetof(struct page_state, GET_PAGE_STATE_LAST);
	55	nr /= sizeof(unsigned long);
	56
	57	__get_page_state(ret, nr+1, &mask);
	58	}
	59
	60	void get_page_state(struct page_state *ret)
	61	{
	62	int nr;
	63	cpumask_t mask = CPU_MASK_ALL;
	64
65	nr = offsetof(struct page_state, GET_PAGE_STATE_LAST);
66	nr /= sizeof(unsigned long);
67
68	__get_page_state(ret, nr + 1, &mask);
69	}
70
71	void get_full_page_state(struct page_state *ret)
72	{
73	cpumask_t mask = CPU_MASK_ALL;
74
75	__get_page_state(ret, sizeof(*ret) / sizeof(unsigned long), &mask);
76	}
77
78	unsigned long read_page_state_offset(unsigned long offset)
79	{
80	unsigned long ret = 0;
81	int cpu;
82
83	for_each_online_cpu(cpu) {
84	unsigned long in;
85
86	in = (unsigned long)&per_cpu(page_states, cpu) + offset;
87	ret += ((unsigned long )in);
88	}
89	return ret;
90	}
91
92	void __mod_page_state_offset(unsigned long offset, unsigned long delta)
93	{
94	void *ptr;
95
96	ptr = &__get_cpu_var(page_states);
97	(unsigned long )(ptr + offset) += delta;
98	}
99	EXPORT_SYMBOL(__mod_page_state_offset);
100
101	void mod_page_state_offset(unsigned long offset, unsigned long delta)
102	{
103	unsigned long flags;
104	void *ptr;
105
106	local_irq_save(flags);
107	ptr = &__get_cpu_var(page_states);
108	(unsigned long )(ptr + offset) += delta;
109	local_irq_restore(flags);
110	}
111	EXPORT_SYMBOL(mod_page_state_offset);
112
113	void __get_zone_counts(unsigned long active, unsigned long inactive,
114	unsigned long free, struct pglist_data pgdat)
115	{
116	struct zone *zones = pgdat->node_zones;
117	int i;
118
119	*active = 0;
120	*inactive = 0;
121	*free = 0;
122	for (i = 0; i < MAX_NR_ZONES; i++) {
123	*active += zones[i].nr_active;
124	*inactive += zones[i].nr_inactive;
125	*free += zones[i].free_pages;
126	}
127	}
128
129	void get_zone_counts(unsigned long *active,
130	unsigned long inactive, unsigned long free)
131	{
132	struct pglist_data *pgdat;
133
134	*active = 0;
135	*inactive = 0;
136	*free = 0;
137	for_each_online_pgdat(pgdat) {
138	unsigned long l, m, n;
139	__get_zone_counts(&l, &m, &n, pgdat);
140	*active += l;
141	*inactive += m;
142	*free += n;
143	}
144	}
145
146	#ifdef CONFIG_PROC_FS
147
148	#include <linux/seq_file.h>
149
150	static void frag_start(struct seq_file m, loff_t *pos)
151	{
152	pg_data_t *pgdat;
153	loff_t node = *pos;
154	for (pgdat = first_online_pgdat();
155	pgdat && node;
156	pgdat = next_online_pgdat(pgdat))
157	--node;
158
159	return pgdat;
160	}
161
162	static void frag_next(struct seq_file m, void arg, loff_t pos)
163	{
164	pg_data_t pgdat = (pg_data_t )arg;
165
166	(*pos)++;
167	return next_online_pgdat(pgdat);
168	}
169
170	static void frag_stop(struct seq_file m, void arg)
171	{
172	}
173
174	/*
175	* This walks the free areas for each zone.
176	*/
177	static int frag_show(struct seq_file m, void arg)
178	{
179	pg_data_t pgdat = (pg_data_t )arg;
180	struct zone *zone;
181	struct zone *node_zones = pgdat->node_zones;
182	unsigned long flags;
183	int order;
184
185	for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) {
186	if (!populated_zone(zone))
187	continue;
188
189	spin_lock_irqsave(&zone->lock, flags);
190	seq_printf(m, "Node %d, zone %8s ", pgdat->node_id, zone->name);
191	for (order = 0; order < MAX_ORDER; ++order)
192	seq_printf(m, "%6lu ", zone->free_area[order].nr_free);
193	spin_unlock_irqrestore(&zone->lock, flags);
194	seq_putc(m, '\n');
195	}
196	return 0;
197	}
198
199	struct seq_operations fragmentation_op = {
200	.start = frag_start,
201	.next = frag_next,
202	.stop = frag_stop,
203	.show = frag_show,
204	};
205
206	static char *vmstat_text[] = {
207	"nr_dirty",
208	"nr_writeback",
209	"nr_unstable",
210	"nr_page_table_pages",
211	"nr_mapped",
212	"nr_slab",
213
214	"pgpgin",
215	"pgpgout",
216	"pswpin",
217	"pswpout",
218
219	"pgalloc_high",
220	"pgalloc_normal",
221	"pgalloc_dma32",
222	"pgalloc_dma",
223
224	"pgfree",
225	"pgactivate",
226	"pgdeactivate",
227
228	"pgfault",
229	"pgmajfault",
230
231	"pgrefill_high",
232	"pgrefill_normal",
233	"pgrefill_dma32",
234	"pgrefill_dma",
235
236	"pgsteal_high",
237	"pgsteal_normal",
238	"pgsteal_dma32",
239	"pgsteal_dma",
240
241	"pgscan_kswapd_high",
242	"pgscan_kswapd_normal",
243	"pgscan_kswapd_dma32",
244	"pgscan_kswapd_dma",
245
246	"pgscan_direct_high",
247	"pgscan_direct_normal",
248	"pgscan_direct_dma32",
249	"pgscan_direct_dma",
250
251	"pginodesteal",
252	"slabs_scanned",
253	"kswapd_steal",
254	"kswapd_inodesteal",
255	"pageoutrun",
256	"allocstall",
257
258	"pgrotated",
259	"nr_bounce",
260	};
261
262	/*
263	* Output information about zones in @pgdat.
264	*/
265	static int zoneinfo_show(struct seq_file m, void arg)
266	{
267	pg_data_t *pgdat = arg;
268	struct zone *zone;
269	struct zone *node_zones = pgdat->node_zones;
270	unsigned long flags;
271
272	for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; zone++) {
273	int i;
274
275	if (!populated_zone(zone))
276	continue;
277
278	spin_lock_irqsave(&zone->lock, flags);
279	seq_printf(m, "Node %d, zone %8s", pgdat->node_id, zone->name);
280	seq_printf(m,
281	"\n pages free %lu"
282	"\n min %lu"
283	"\n low %lu"
284	"\n high %lu"
285	"\n active %lu"
286	"\n inactive %lu"
287	"\n scanned %lu (a: %lu i: %lu)"
288	"\n spanned %lu"
289	"\n present %lu",
290	zone->free_pages,
291	zone->pages_min,
292	zone->pages_low,
293	zone->pages_high,
294	zone->nr_active,
295	zone->nr_inactive,
296	zone->pages_scanned,
297	zone->nr_scan_active, zone->nr_scan_inactive,
298	zone->spanned_pages,
299	zone->present_pages);
300	seq_printf(m,
301	"\n protection: (%lu",
302	zone->lowmem_reserve[0]);
303	for (i = 1; i < ARRAY_SIZE(zone->lowmem_reserve); i++)
304	seq_printf(m, ", %lu", zone->lowmem_reserve[i]);
305	seq_printf(m,
306	")"
307	"\n pagesets");
308	for_each_online_cpu(i) {
309	struct per_cpu_pageset *pageset;
310	int j;
311
312	pageset = zone_pcp(zone, i);
313	for (j = 0; j < ARRAY_SIZE(pageset->pcp); j++) {
314	if (pageset->pcp[j].count)
315	break;
316	}
317	if (j == ARRAY_SIZE(pageset->pcp))
318	continue;
319	for (j = 0; j < ARRAY_SIZE(pageset->pcp); j++) {
320	seq_printf(m,
321	"\n cpu: %i pcp: %i"
322	"\n count: %i"
323	"\n high: %i"
324	"\n batch: %i",
325	i, j,
326	pageset->pcp[j].count,
327	pageset->pcp[j].high,
328	pageset->pcp[j].batch);
329	}
330	#ifdef CONFIG_NUMA
331	seq_printf(m,
332	"\n numa_hit: %lu"
333	"\n numa_miss: %lu"
334	"\n numa_foreign: %lu"
335	"\n interleave_hit: %lu"
336	"\n local_node: %lu"
337	"\n other_node: %lu",
338	pageset->numa_hit,
339	pageset->numa_miss,
340	pageset->numa_foreign,
341	pageset->interleave_hit,
342	pageset->local_node,
343	pageset->other_node);
344	#endif
345	}
346	seq_printf(m,
347	"\n all_unreclaimable: %u"
348	"\n prev_priority: %i"
349	"\n temp_priority: %i"
350	"\n start_pfn: %lu",
351	zone->all_unreclaimable,
352	zone->prev_priority,
353	zone->temp_priority,
354	zone->zone_start_pfn);
355	spin_unlock_irqrestore(&zone->lock, flags);
356	seq_putc(m, '\n');
357	}
358	return 0;
359	}
360
361	struct seq_operations zoneinfo_op = {
362	.start = frag_start, /* iterate over all zones. The same as in
363	* fragmentation. */
364	.next = frag_next,
365	.stop = frag_stop,
366	.show = zoneinfo_show,
367	};
368
369	static void vmstat_start(struct seq_file m, loff_t *pos)
370	{
371	struct page_state *ps;
372
373	if (*pos >= ARRAY_SIZE(vmstat_text))
374	return NULL;
375
376	ps = kmalloc(sizeof(*ps), GFP_KERNEL);
377	m->private = ps;
378	if (!ps)
379	return ERR_PTR(-ENOMEM);
380	get_full_page_state(ps);
381	ps->pgpgin /= 2; /* sectors -> kbytes */
382	ps->pgpgout /= 2;
383	return (unsigned long )ps + pos;
384	}
385
386	static void vmstat_next(struct seq_file m, void arg, loff_t pos)
387	{
388	(*pos)++;
389	if (*pos >= ARRAY_SIZE(vmstat_text))
390	return NULL;
391	return (unsigned long )m->private + pos;
392	}
393
394	static int vmstat_show(struct seq_file m, void arg)
395	{
396	unsigned long *l = arg;
397	unsigned long off = l - (unsigned long *)m->private;
398
399	seq_printf(m, "%s %lu\n", vmstat_text[off], *l);
400	return 0;
401	}
402
403	static void vmstat_stop(struct seq_file m, void arg)
404	{
405	kfree(m->private);
406	m->private = NULL;
407	}
408
409	struct seq_operations vmstat_op = {
410	.start = vmstat_start,
411	.next = vmstat_next,
412	.stop = vmstat_stop,
413	.show = vmstat_show,
414	};
415
416	#endif /* CONFIG_PROC_FS */
417