vmstat.h 6.52 KB
Newer Older
1 2 3 4 5
#ifndef _LINUX_VMSTAT_H
#define _LINUX_VMSTAT_H

#include <linux/types.h>
#include <linux/percpu.h>
6
#include <linux/mm.h>
7 8
#include <linux/mmzone.h>
#include <asm/atomic.h>
9

10
#ifdef CONFIG_VM_EVENT_COUNTERS
11
/*
12
 * Light weight per cpu counter implementation.
13
 *
14 15 16
 * Counters should only be incremented.  You need to set EMBEDDED
 * to disable VM_EVENT_COUNTERS.  Things like procps (vmstat,
 * top, etc) use /proc/vmstat and depend on these counters.
17 18 19
 *
 * Counters are handled completely inline. On many platforms the code
 * generated will simply be the increment of a global address.
20
 */
21

22 23 24 25 26 27
#ifdef CONFIG_ZONE_DMA
#define DMA_ZONE(xx) xx##_DMA,
#else
#define DMA_ZONE(xx)
#endif

28 29 30 31 32 33 34 35 36 37 38 39
#ifdef CONFIG_ZONE_DMA32
#define DMA32_ZONE(xx) xx##_DMA32,
#else
#define DMA32_ZONE(xx)
#endif

#ifdef CONFIG_HIGHMEM
#define HIGHMEM_ZONE(xx) , xx##_HIGH
#else
#define HIGHMEM_ZONE(xx)
#endif

40
#define FOR_ALL_ZONES(xx) DMA_ZONE(xx) DMA32_ZONE(xx) xx##_NORMAL HIGHMEM_ZONE(xx)
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56

enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
		FOR_ALL_ZONES(PGALLOC),
		PGFREE, PGACTIVATE, PGDEACTIVATE,
		PGFAULT, PGMAJFAULT,
		FOR_ALL_ZONES(PGREFILL),
		FOR_ALL_ZONES(PGSTEAL),
		FOR_ALL_ZONES(PGSCAN_KSWAPD),
		FOR_ALL_ZONES(PGSCAN_DIRECT),
		PGINODESTEAL, SLABS_SCANNED, KSWAPD_STEAL, KSWAPD_INODESTEAL,
		PAGEOUTRUN, ALLOCSTALL, PGROTATED,
		NR_VM_EVENT_ITEMS
};

struct vm_event_state {
	unsigned long event[NR_VM_EVENT_ITEMS];
57 58
};

59 60 61 62
DECLARE_PER_CPU(struct vm_event_state, vm_event_states);

static inline void __count_vm_event(enum vm_event_item item)
{
63
	__get_cpu_var(vm_event_states).event[item]++;
64 65 66 67
}

static inline void count_vm_event(enum vm_event_item item)
{
68
	get_cpu_var(vm_event_states).event[item]++;
69 70 71 72 73
	put_cpu();
}

static inline void __count_vm_events(enum vm_event_item item, long delta)
{
74
	__get_cpu_var(vm_event_states).event[item] += delta;
75 76 77 78
}

static inline void count_vm_events(enum vm_event_item item, long delta)
{
79
	get_cpu_var(vm_event_states).event[item] += delta;
80 81 82 83
	put_cpu();
}

extern void all_vm_events(unsigned long *);
84
#ifdef CONFIG_HOTPLUG
85
extern void vm_events_fold_cpu(int cpu);
86 87 88 89 90
#else
static inline void vm_events_fold_cpu(int cpu)
{
}
#endif
91 92 93 94 95 96 97 98 99 100 101 102 103 104

#else

/* Disable counters */
#define get_cpu_vm_events(e)	0L
#define count_vm_event(e)	do { } while (0)
#define count_vm_events(e,d)	do { } while (0)
#define __count_vm_event(e)	do { } while (0)
#define __count_vm_events(e,d)	do { } while (0)
#define vm_events_fold_cpu(x)	do { } while (0)

#endif /* CONFIG_VM_EVENT_COUNTERS */

#define __count_zone_vm_events(item, zone, delta) \
105 106
		__count_vm_events(item##_NORMAL - ZONE_NORMAL + \
		zone_idx(zone), delta)
107

108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
/*
 * Zone based page accounting with per cpu differentials.
 */
extern atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];

static inline void zone_page_state_add(long x, struct zone *zone,
				 enum zone_stat_item item)
{
	atomic_long_add(x, &zone->vm_stat[item]);
	atomic_long_add(x, &vm_stat[item]);
}

static inline unsigned long global_page_state(enum zone_stat_item item)
{
	long x = atomic_long_read(&vm_stat[item]);
#ifdef CONFIG_SMP
	if (x < 0)
		x = 0;
#endif
	return x;
}

static inline unsigned long zone_page_state(struct zone *zone,
					enum zone_stat_item item)
{
	long x = atomic_long_read(&zone->vm_stat[item]);
#ifdef CONFIG_SMP
	if (x < 0)
		x = 0;
#endif
	return x;
}

#ifdef CONFIG_NUMA
/*
 * Determine the per node value of a stat item. This function
 * is called frequently in a NUMA machine, so try to be as
 * frugal as possible.
 */
static inline unsigned long node_page_state(int node,
				 enum zone_stat_item item)
{
	struct zone *zones = NODE_DATA(node)->node_zones;

	return
153 154 155
#ifdef CONFIG_ZONE_DMA
		zone_page_state(&zones[ZONE_DMA], item) +
#endif
156
#ifdef CONFIG_ZONE_DMA32
157 158 159 160 161
		zone_page_state(&zones[ZONE_DMA32], item) +
#endif
#ifdef CONFIG_HIGHMEM
		zone_page_state(&zones[ZONE_HIGHMEM], item) +
#endif
162
		zone_page_state(&zones[ZONE_NORMAL], item);
163
}
164 165 166

extern void zone_statistics(struct zonelist *, struct zone *);

167
#else
168

169
#define node_page_state(node, item) global_page_state(item)
170 171 172
#define zone_statistics(_zl,_z) do { } while (0)

#endif /* CONFIG_NUMA */
173 174 175 176 177 178 179 180 181 182 183 184 185 186

#define __add_zone_page_state(__z, __i, __d)	\
		__mod_zone_page_state(__z, __i, __d)
#define __sub_zone_page_state(__z, __i, __d)	\
		__mod_zone_page_state(__z, __i,-(__d))

#define add_zone_page_state(__z, __i, __d) mod_zone_page_state(__z, __i, __d)
#define sub_zone_page_state(__z, __i, __d) mod_zone_page_state(__z, __i, -(__d))

static inline void zap_zone_vm_stats(struct zone *zone)
{
	memset(zone->vm_stat, 0, sizeof(zone->vm_stat));
}

187 188
extern void inc_zone_state(struct zone *, enum zone_stat_item);

189 190 191 192
#ifdef CONFIG_SMP
void __mod_zone_page_state(struct zone *, enum zone_stat_item item, int);
void __inc_zone_page_state(struct page *, enum zone_stat_item);
void __dec_zone_page_state(struct page *, enum zone_stat_item);
193

194 195 196 197 198
void mod_zone_page_state(struct zone *, enum zone_stat_item, int);
void inc_zone_page_state(struct page *, enum zone_stat_item);
void dec_zone_page_state(struct page *, enum zone_stat_item);

extern void inc_zone_state(struct zone *, enum zone_stat_item);
199 200 201
extern void __inc_zone_state(struct zone *, enum zone_stat_item);
extern void dec_zone_state(struct zone *, enum zone_stat_item);
extern void __dec_zone_state(struct zone *, enum zone_stat_item);
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217

void refresh_cpu_vm_stats(int);
void refresh_vm_stats(void);

#else /* CONFIG_SMP */

/*
 * We do not maintain differentials in a single processor configuration.
 * The functions directly modify the zone and global counters.
 */
static inline void __mod_zone_page_state(struct zone *zone,
			enum zone_stat_item item, int delta)
{
	zone_page_state_add(delta, zone, item);
}

218 219 220 221 222 223
static inline void __inc_zone_state(struct zone *zone, enum zone_stat_item item)
{
	atomic_long_inc(&zone->vm_stat[item]);
	atomic_long_inc(&vm_stat[item]);
}

224 225 226
static inline void __inc_zone_page_state(struct page *page,
			enum zone_stat_item item)
{
227
	__inc_zone_state(page_zone(page), item);
228 229
}

230 231 232 233 234 235
static inline void __dec_zone_state(struct zone *zone, enum zone_stat_item item)
{
	atomic_long_dec(&zone->vm_stat[item]);
	atomic_long_dec(&vm_stat[item]);
}

236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
static inline void __dec_zone_page_state(struct page *page,
			enum zone_stat_item item)
{
	atomic_long_dec(&page_zone(page)->vm_stat[item]);
	atomic_long_dec(&vm_stat[item]);
}

/*
 * We only use atomic operations to update counters. So there is no need to
 * disable interrupts.
 */
#define inc_zone_page_state __inc_zone_page_state
#define dec_zone_page_state __dec_zone_page_state
#define mod_zone_page_state __mod_zone_page_state

static inline void refresh_cpu_vm_stats(int cpu) { }
static inline void refresh_vm_stats(void) { }
#endif

#endif /* _LINUX_VMSTAT_H */