1 #ifndef _LINUX_VMSTAT_H 2 #define _LINUX_VMSTAT_H 3 4 #include <linux/types.h> 5 #include <linux/percpu.h> 6 #include <linux/mm.h> 7 #include <linux/mmzone.h> 8 #include <asm/atomic.h> 9 10 #ifdef CONFIG_ZONE_DMA 11 #define DMA_ZONE(xx) xx##_DMA, 12 #else 13 #define DMA_ZONE(xx) 14 #endif 15 16 #ifdef CONFIG_ZONE_DMA32 17 #define DMA32_ZONE(xx) xx##_DMA32, 18 #else 19 #define DMA32_ZONE(xx) 20 #endif 21 22 #ifdef CONFIG_HIGHMEM 23 #define HIGHMEM_ZONE(xx) , xx##_HIGH 24 #else 25 #define HIGHMEM_ZONE(xx) 26 #endif 27 28 29 #define FOR_ALL_ZONES(xx) DMA_ZONE(xx) DMA32_ZONE(xx) xx##_NORMAL HIGHMEM_ZONE(xx) , xx##_MOVABLE 30 31 enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT, 32 FOR_ALL_ZONES(PGALLOC), 33 PGFREE, PGACTIVATE, PGDEACTIVATE, 34 PGFAULT, PGMAJFAULT, 35 FOR_ALL_ZONES(PGREFILL), 36 FOR_ALL_ZONES(PGSTEAL), 37 FOR_ALL_ZONES(PGSCAN_KSWAPD), 38 FOR_ALL_ZONES(PGSCAN_DIRECT), 39 PGINODESTEAL, SLABS_SCANNED, KSWAPD_STEAL, KSWAPD_INODESTEAL, 40 PAGEOUTRUN, ALLOCSTALL, PGROTATED, 41 #ifdef CONFIG_HUGETLB_PAGE 42 HTLB_BUDDY_PGALLOC, HTLB_BUDDY_PGALLOC_FAIL, 43 #endif 44 NR_VM_EVENT_ITEMS 45 }; 46 47 extern const struct seq_operations fragmentation_op; 48 extern const struct seq_operations pagetypeinfo_op; 49 extern const struct seq_operations zoneinfo_op; 50 extern const struct seq_operations vmstat_op; 51 extern int sysctl_stat_interval; 52 53 #ifdef CONFIG_VM_EVENT_COUNTERS 54 /* 55 * Light weight per cpu counter implementation. 56 * 57 * Counters should only be incremented and no critical kernel component 58 * should rely on the counter values. 59 * 60 * Counters are handled completely inline. On many platforms the code 61 * generated will simply be the increment of a global address. 62 */ 63 64 struct vm_event_state { 65 unsigned long event[NR_VM_EVENT_ITEMS]; 66 }; 67 68 DECLARE_PER_CPU(struct vm_event_state, vm_event_states); 69 70 static inline void __count_vm_event(enum vm_event_item item) 71 { 72 __get_cpu_var(vm_event_states).event[item]++; 73 } 74 75 static inline void count_vm_event(enum vm_event_item item) 76 { 77 get_cpu_var(vm_event_states).event[item]++; 78 put_cpu(); 79 } 80 81 static inline void __count_vm_events(enum vm_event_item item, long delta) 82 { 83 __get_cpu_var(vm_event_states).event[item] += delta; 84 } 85 86 static inline void count_vm_events(enum vm_event_item item, long delta) 87 { 88 get_cpu_var(vm_event_states).event[item] += delta; 89 put_cpu(); 90 } 91 92 extern void all_vm_events(unsigned long *); 93 #ifdef CONFIG_HOTPLUG 94 extern void vm_events_fold_cpu(int cpu); 95 #else 96 static inline void vm_events_fold_cpu(int cpu) 97 { 98 } 99 #endif 100 101 #else 102 103 /* Disable counters */ 104 static inline void count_vm_event(enum vm_event_item item) 105 { 106 } 107 static inline void count_vm_events(enum vm_event_item item, long delta) 108 { 109 } 110 static inline void __count_vm_event(enum vm_event_item item) 111 { 112 } 113 static inline void __count_vm_events(enum vm_event_item item, long delta) 114 { 115 } 116 static inline void all_vm_events(unsigned long *ret) 117 { 118 } 119 static inline void vm_events_fold_cpu(int cpu) 120 { 121 } 122 123 #endif /* CONFIG_VM_EVENT_COUNTERS */ 124 125 #define __count_zone_vm_events(item, zone, delta) \ 126 __count_vm_events(item##_NORMAL - ZONE_NORMAL + \ 127 zone_idx(zone), delta) 128 129 /* 130 * Zone based page accounting with per cpu differentials. 131 */ 132 extern atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS]; 133 134 static inline void zone_page_state_add(long x, struct zone *zone, 135 enum zone_stat_item item) 136 { 137 atomic_long_add(x, &zone->vm_stat[item]); 138 atomic_long_add(x, &vm_stat[item]); 139 } 140 141 static inline unsigned long global_page_state(enum zone_stat_item item) 142 { 143 long x = atomic_long_read(&vm_stat[item]); 144 #ifdef CONFIG_SMP 145 if (x < 0) 146 x = 0; 147 #endif 148 return x; 149 } 150 151 static inline unsigned long zone_page_state(struct zone *zone, 152 enum zone_stat_item item) 153 { 154 long x = atomic_long_read(&zone->vm_stat[item]); 155 #ifdef CONFIG_SMP 156 if (x < 0) 157 x = 0; 158 #endif 159 return x; 160 } 161 162 #ifdef CONFIG_NUMA 163 /* 164 * Determine the per node value of a stat item. This function 165 * is called frequently in a NUMA machine, so try to be as 166 * frugal as possible. 167 */ 168 static inline unsigned long node_page_state(int node, 169 enum zone_stat_item item) 170 { 171 struct zone *zones = NODE_DATA(node)->node_zones; 172 173 return 174 #ifdef CONFIG_ZONE_DMA 175 zone_page_state(&zones[ZONE_DMA], item) + 176 #endif 177 #ifdef CONFIG_ZONE_DMA32 178 zone_page_state(&zones[ZONE_DMA32], item) + 179 #endif 180 #ifdef CONFIG_HIGHMEM 181 zone_page_state(&zones[ZONE_HIGHMEM], item) + 182 #endif 183 zone_page_state(&zones[ZONE_NORMAL], item) + 184 zone_page_state(&zones[ZONE_MOVABLE], item); 185 } 186 187 extern void zone_statistics(struct zone *, struct zone *); 188 189 #else 190 191 #define node_page_state(node, item) global_page_state(item) 192 #define zone_statistics(_zl,_z) do { } while (0) 193 194 #endif /* CONFIG_NUMA */ 195 196 #define __add_zone_page_state(__z, __i, __d) \ 197 __mod_zone_page_state(__z, __i, __d) 198 #define __sub_zone_page_state(__z, __i, __d) \ 199 __mod_zone_page_state(__z, __i,-(__d)) 200 201 #define add_zone_page_state(__z, __i, __d) mod_zone_page_state(__z, __i, __d) 202 #define sub_zone_page_state(__z, __i, __d) mod_zone_page_state(__z, __i, -(__d)) 203 204 static inline void zap_zone_vm_stats(struct zone *zone) 205 { 206 memset(zone->vm_stat, 0, sizeof(zone->vm_stat)); 207 } 208 209 extern void inc_zone_state(struct zone *, enum zone_stat_item); 210 211 #ifdef CONFIG_SMP 212 void __mod_zone_page_state(struct zone *, enum zone_stat_item item, int); 213 void __inc_zone_page_state(struct page *, enum zone_stat_item); 214 void __dec_zone_page_state(struct page *, enum zone_stat_item); 215 216 void mod_zone_page_state(struct zone *, enum zone_stat_item, int); 217 void inc_zone_page_state(struct page *, enum zone_stat_item); 218 void dec_zone_page_state(struct page *, enum zone_stat_item); 219 220 extern void inc_zone_state(struct zone *, enum zone_stat_item); 221 extern void __inc_zone_state(struct zone *, enum zone_stat_item); 222 extern void dec_zone_state(struct zone *, enum zone_stat_item); 223 extern void __dec_zone_state(struct zone *, enum zone_stat_item); 224 225 void refresh_cpu_vm_stats(int); 226 #else /* CONFIG_SMP */ 227 228 /* 229 * We do not maintain differentials in a single processor configuration. 230 * The functions directly modify the zone and global counters. 231 */ 232 static inline void __mod_zone_page_state(struct zone *zone, 233 enum zone_stat_item item, int delta) 234 { 235 zone_page_state_add(delta, zone, item); 236 } 237 238 static inline void __inc_zone_state(struct zone *zone, enum zone_stat_item item) 239 { 240 atomic_long_inc(&zone->vm_stat[item]); 241 atomic_long_inc(&vm_stat[item]); 242 } 243 244 static inline void __inc_zone_page_state(struct page *page, 245 enum zone_stat_item item) 246 { 247 __inc_zone_state(page_zone(page), item); 248 } 249 250 static inline void __dec_zone_state(struct zone *zone, enum zone_stat_item item) 251 { 252 atomic_long_dec(&zone->vm_stat[item]); 253 atomic_long_dec(&vm_stat[item]); 254 } 255 256 static inline void __dec_zone_page_state(struct page *page, 257 enum zone_stat_item item) 258 { 259 __dec_zone_state(page_zone(page), item); 260 } 261 262 /* 263 * We only use atomic operations to update counters. So there is no need to 264 * disable interrupts. 265 */ 266 #define inc_zone_page_state __inc_zone_page_state 267 #define dec_zone_page_state __dec_zone_page_state 268 #define mod_zone_page_state __mod_zone_page_state 269 270 static inline void refresh_cpu_vm_stats(int cpu) { } 271 #endif 272 273 #endif /* _LINUX_VMSTAT_H */ 274