1 #ifndef _LINUX_VMSTAT_H
2 #define _LINUX_VMSTAT_H
4 #include <linux/types.h>
5 #include <linux/percpu.h>
6 #include <linux/mmzone.h>
7 #include <asm/atomic.h>
9 #ifdef CONFIG_VM_EVENT_COUNTERS
11 * Light weight per cpu counter implementation.
13 * Counters should only be incremented. You need to set EMBEDDED
14 * to disable VM_EVENT_COUNTERS. Things like procps (vmstat,
15 * top, etc) use /proc/vmstat and depend on these counters.
17 * Counters are handled completely inline. On many platforms the code
18 * generated will simply be the increment of a global address.
21 #ifdef CONFIG_ZONE_DMA32
22 #define DMA32_ZONE(xx) xx##_DMA32,
24 #define DMA32_ZONE(xx)
28 #define HIGHMEM_ZONE(xx) , xx##_HIGH
30 #define HIGHMEM_ZONE(xx)
33 #define FOR_ALL_ZONES(xx) xx##_DMA, DMA32_ZONE(xx) xx##_NORMAL HIGHMEM_ZONE(xx)
35 enum vm_event_item
{ PGPGIN
, PGPGOUT
, PSWPIN
, PSWPOUT
,
36 FOR_ALL_ZONES(PGALLOC
),
37 PGFREE
, PGACTIVATE
, PGDEACTIVATE
,
39 FOR_ALL_ZONES(PGREFILL
),
40 FOR_ALL_ZONES(PGSTEAL
),
41 FOR_ALL_ZONES(PGSCAN_KSWAPD
),
42 FOR_ALL_ZONES(PGSCAN_DIRECT
),
43 PGINODESTEAL
, SLABS_SCANNED
, KSWAPD_STEAL
, KSWAPD_INODESTEAL
,
44 PAGEOUTRUN
, ALLOCSTALL
, PGROTATED
,
48 struct vm_event_state
{
49 unsigned long event
[NR_VM_EVENT_ITEMS
];
52 DECLARE_PER_CPU(struct vm_event_state
, vm_event_states
);
54 static inline void __count_vm_event(enum vm_event_item item
)
56 __get_cpu_var(vm_event_states
).event
[item
]++;
59 static inline void count_vm_event(enum vm_event_item item
)
61 get_cpu_var(vm_event_states
).event
[item
]++;
65 static inline void __count_vm_events(enum vm_event_item item
, long delta
)
67 __get_cpu_var(vm_event_states
).event
[item
] += delta
;
70 static inline void count_vm_events(enum vm_event_item item
, long delta
)
72 get_cpu_var(vm_event_states
).event
[item
] += delta
;
76 extern void all_vm_events(unsigned long *);
78 extern void vm_events_fold_cpu(int cpu
);
80 static inline void vm_events_fold_cpu(int cpu
)
87 /* Disable counters */
88 #define get_cpu_vm_events(e) 0L
89 #define count_vm_event(e) do { } while (0)
90 #define count_vm_events(e,d) do { } while (0)
91 #define __count_vm_event(e) do { } while (0)
92 #define __count_vm_events(e,d) do { } while (0)
93 #define vm_events_fold_cpu(x) do { } while (0)
95 #endif /* CONFIG_VM_EVENT_COUNTERS */
97 #define __count_zone_vm_events(item, zone, delta) \
98 __count_vm_events(item##_DMA + zone_idx(zone), delta)
101 * Zone based page accounting with per cpu differentials.
103 extern atomic_long_t vm_stat
[NR_VM_ZONE_STAT_ITEMS
];
105 static inline void zone_page_state_add(long x
, struct zone
*zone
,
106 enum zone_stat_item item
)
108 atomic_long_add(x
, &zone
->vm_stat
[item
]);
109 atomic_long_add(x
, &vm_stat
[item
]);
112 static inline unsigned long global_page_state(enum zone_stat_item item
)
114 long x
= atomic_long_read(&vm_stat
[item
]);
122 static inline unsigned long zone_page_state(struct zone
*zone
,
123 enum zone_stat_item item
)
125 long x
= atomic_long_read(&zone
->vm_stat
[item
]);
135 * Determine the per node value of a stat item. This function
136 * is called frequently in a NUMA machine, so try to be as
137 * frugal as possible.
139 static inline unsigned long node_page_state(int node
,
140 enum zone_stat_item item
)
142 struct zone
*zones
= NODE_DATA(node
)->node_zones
;
145 #ifdef CONFIG_ZONE_DMA32
146 zone_page_state(&zones
[ZONE_DMA32
], item
) +
148 zone_page_state(&zones
[ZONE_NORMAL
], item
) +
149 #ifdef CONFIG_HIGHMEM
150 zone_page_state(&zones
[ZONE_HIGHMEM
], item
) +
152 zone_page_state(&zones
[ZONE_DMA
], item
);
155 extern void zone_statistics(struct zonelist
*, struct zone
*);
159 #define node_page_state(node, item) global_page_state(item)
160 #define zone_statistics(_zl,_z) do { } while (0)
162 #endif /* CONFIG_NUMA */
164 #define __add_zone_page_state(__z, __i, __d) \
165 __mod_zone_page_state(__z, __i, __d)
166 #define __sub_zone_page_state(__z, __i, __d) \
167 __mod_zone_page_state(__z, __i,-(__d))
169 #define add_zone_page_state(__z, __i, __d) mod_zone_page_state(__z, __i, __d)
170 #define sub_zone_page_state(__z, __i, __d) mod_zone_page_state(__z, __i, -(__d))
172 static inline void zap_zone_vm_stats(struct zone
*zone
)
174 memset(zone
->vm_stat
, 0, sizeof(zone
->vm_stat
));
177 extern void inc_zone_state(struct zone
*, enum zone_stat_item
);
180 void __mod_zone_page_state(struct zone
*, enum zone_stat_item item
, int);
181 void __inc_zone_page_state(struct page
*, enum zone_stat_item
);
182 void __dec_zone_page_state(struct page
*, enum zone_stat_item
);
184 void mod_zone_page_state(struct zone
*, enum zone_stat_item
, int);
185 void inc_zone_page_state(struct page
*, enum zone_stat_item
);
186 void dec_zone_page_state(struct page
*, enum zone_stat_item
);
188 extern void inc_zone_state(struct zone
*, enum zone_stat_item
);
190 void refresh_cpu_vm_stats(int);
191 void refresh_vm_stats(void);
193 #else /* CONFIG_SMP */
196 * We do not maintain differentials in a single processor configuration.
197 * The functions directly modify the zone and global counters.
199 static inline void __mod_zone_page_state(struct zone
*zone
,
200 enum zone_stat_item item
, int delta
)
202 zone_page_state_add(delta
, zone
, item
);
205 static inline void __inc_zone_state(struct zone
*zone
, enum zone_stat_item item
)
207 atomic_long_inc(&zone
->vm_stat
[item
]);
208 atomic_long_inc(&vm_stat
[item
]);
211 static inline void __inc_zone_page_state(struct page
*page
,
212 enum zone_stat_item item
)
214 __inc_zone_state(page_zone(page
), item
);
217 static inline void __dec_zone_page_state(struct page
*page
,
218 enum zone_stat_item item
)
220 atomic_long_dec(&page_zone(page
)->vm_stat
[item
]);
221 atomic_long_dec(&vm_stat
[item
]);
225 * We only use atomic operations to update counters. So there is no need to
226 * disable interrupts.
228 #define inc_zone_page_state __inc_zone_page_state
229 #define dec_zone_page_state __dec_zone_page_state
230 #define mod_zone_page_state __mod_zone_page_state
232 static inline void refresh_cpu_vm_stats(int cpu
) { }
233 static inline void refresh_vm_stats(void) { }
236 #endif /* _LINUX_VMSTAT_H */