memcg: remove direct page_cgroup-to-page pointer
[linux-2.6.git] / include / linux / page_cgroup.h
1 #ifndef __LINUX_PAGE_CGROUP_H
2 #define __LINUX_PAGE_CGROUP_H
3
4 enum {
5         /* flags for mem_cgroup */
6         PCG_LOCK,  /* Lock for pc->mem_cgroup and following bits. */
7         PCG_CACHE, /* charged as cache */
8         PCG_USED, /* this object is in use. */
9         PCG_MIGRATION, /* under page migration */
10         /* flags for mem_cgroup and file and I/O status */
11         PCG_MOVE_LOCK, /* For race between move_account v.s. following bits */
12         PCG_FILE_MAPPED, /* page is accounted as "mapped" */
13         /* No lock in page_cgroup */
14         PCG_ACCT_LRU, /* page has been accounted for (under lru_lock) */
15         __NR_PCG_FLAGS,
16 };
17
18 #ifndef __GENERATING_BOUNDS_H
19 #include <generated/bounds.h>
20
21 #ifdef CONFIG_CGROUP_MEM_RES_CTLR
22 #include <linux/bit_spinlock.h>
23
24 /*
25  * Page Cgroup can be considered as an extended mem_map.
26  * A page_cgroup page is associated with every page descriptor. The
27  * page_cgroup helps us identify information about the cgroup
28  * All page cgroups are allocated at boot or memory hotplug event,
29  * then the page cgroup for pfn always exists.
30  */
31 struct page_cgroup {
32         unsigned long flags;
33         struct mem_cgroup *mem_cgroup;
34         struct list_head lru;           /* per cgroup LRU list */
35 };
36
37 void __meminit pgdat_page_cgroup_init(struct pglist_data *pgdat);
38
39 #ifdef CONFIG_SPARSEMEM
40 static inline void __init page_cgroup_init_flatmem(void)
41 {
42 }
43 extern void __init page_cgroup_init(void);
44 #else
45 void __init page_cgroup_init_flatmem(void);
46 static inline void __init page_cgroup_init(void)
47 {
48 }
49 #endif
50
51 struct page_cgroup *lookup_page_cgroup(struct page *page);
52 struct page *lookup_cgroup_page(struct page_cgroup *pc);
53
54 #define TESTPCGFLAG(uname, lname)                       \
55 static inline int PageCgroup##uname(struct page_cgroup *pc)     \
56         { return test_bit(PCG_##lname, &pc->flags); }
57
58 #define SETPCGFLAG(uname, lname)                        \
59 static inline void SetPageCgroup##uname(struct page_cgroup *pc)\
60         { set_bit(PCG_##lname, &pc->flags);  }
61
62 #define CLEARPCGFLAG(uname, lname)                      \
63 static inline void ClearPageCgroup##uname(struct page_cgroup *pc)       \
64         { clear_bit(PCG_##lname, &pc->flags);  }
65
66 #define TESTCLEARPCGFLAG(uname, lname)                  \
67 static inline int TestClearPageCgroup##uname(struct page_cgroup *pc)    \
68         { return test_and_clear_bit(PCG_##lname, &pc->flags);  }
69
70 /* Cache flag is set only once (at allocation) */
71 TESTPCGFLAG(Cache, CACHE)
72 CLEARPCGFLAG(Cache, CACHE)
73 SETPCGFLAG(Cache, CACHE)
74
75 TESTPCGFLAG(Used, USED)
76 CLEARPCGFLAG(Used, USED)
77 SETPCGFLAG(Used, USED)
78
79 SETPCGFLAG(AcctLRU, ACCT_LRU)
80 CLEARPCGFLAG(AcctLRU, ACCT_LRU)
81 TESTPCGFLAG(AcctLRU, ACCT_LRU)
82 TESTCLEARPCGFLAG(AcctLRU, ACCT_LRU)
83
84
85 SETPCGFLAG(FileMapped, FILE_MAPPED)
86 CLEARPCGFLAG(FileMapped, FILE_MAPPED)
87 TESTPCGFLAG(FileMapped, FILE_MAPPED)
88
89 SETPCGFLAG(Migration, MIGRATION)
90 CLEARPCGFLAG(Migration, MIGRATION)
91 TESTPCGFLAG(Migration, MIGRATION)
92
93 static inline void lock_page_cgroup(struct page_cgroup *pc)
94 {
95         /*
96          * Don't take this lock in IRQ context.
97          * This lock is for pc->mem_cgroup, USED, CACHE, MIGRATION
98          */
99         bit_spin_lock(PCG_LOCK, &pc->flags);
100 }
101
102 static inline void unlock_page_cgroup(struct page_cgroup *pc)
103 {
104         bit_spin_unlock(PCG_LOCK, &pc->flags);
105 }
106
107 static inline void move_lock_page_cgroup(struct page_cgroup *pc,
108         unsigned long *flags)
109 {
110         /*
111          * We know updates to pc->flags of page cache's stats are from both of
112          * usual context or IRQ context. Disable IRQ to avoid deadlock.
113          */
114         local_irq_save(*flags);
115         bit_spin_lock(PCG_MOVE_LOCK, &pc->flags);
116 }
117
118 static inline void move_unlock_page_cgroup(struct page_cgroup *pc,
119         unsigned long *flags)
120 {
121         bit_spin_unlock(PCG_MOVE_LOCK, &pc->flags);
122         local_irq_restore(*flags);
123 }
124
125 #ifdef CONFIG_SPARSEMEM
126 #define PCG_ARRAYID_WIDTH       SECTIONS_SHIFT
127 #else
128 #define PCG_ARRAYID_WIDTH       NODES_SHIFT
129 #endif
130
131 #if (PCG_ARRAYID_WIDTH > BITS_PER_LONG - NR_PCG_FLAGS)
132 #error Not enough space left in pc->flags to store page_cgroup array IDs
133 #endif
134
135 /* pc->flags: ARRAY-ID | FLAGS */
136
137 #define PCG_ARRAYID_MASK        ((1UL << PCG_ARRAYID_WIDTH) - 1)
138
139 #define PCG_ARRAYID_OFFSET      (BITS_PER_LONG - PCG_ARRAYID_WIDTH)
140 /*
141  * Zero the shift count for non-existant fields, to prevent compiler
142  * warnings and ensure references are optimized away.
143  */
144 #define PCG_ARRAYID_SHIFT       (PCG_ARRAYID_OFFSET * (PCG_ARRAYID_WIDTH != 0))
145
146 static inline void set_page_cgroup_array_id(struct page_cgroup *pc,
147                                             unsigned long id)
148 {
149         pc->flags &= ~(PCG_ARRAYID_MASK << PCG_ARRAYID_SHIFT);
150         pc->flags |= (id & PCG_ARRAYID_MASK) << PCG_ARRAYID_SHIFT;
151 }
152
153 static inline unsigned long page_cgroup_array_id(struct page_cgroup *pc)
154 {
155         return (pc->flags >> PCG_ARRAYID_SHIFT) & PCG_ARRAYID_MASK;
156 }
157
158 #else /* CONFIG_CGROUP_MEM_RES_CTLR */
159 struct page_cgroup;
160
161 static inline void __meminit pgdat_page_cgroup_init(struct pglist_data *pgdat)
162 {
163 }
164
165 static inline struct page_cgroup *lookup_page_cgroup(struct page *page)
166 {
167         return NULL;
168 }
169
170 static inline void page_cgroup_init(void)
171 {
172 }
173
174 static inline void __init page_cgroup_init_flatmem(void)
175 {
176 }
177
178 #endif /* CONFIG_CGROUP_MEM_RES_CTLR */
179
180 #include <linux/swap.h>
181
182 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
183 extern unsigned short swap_cgroup_cmpxchg(swp_entry_t ent,
184                                         unsigned short old, unsigned short new);
185 extern unsigned short swap_cgroup_record(swp_entry_t ent, unsigned short id);
186 extern unsigned short lookup_swap_cgroup(swp_entry_t ent);
187 extern int swap_cgroup_swapon(int type, unsigned long max_pages);
188 extern void swap_cgroup_swapoff(int type);
189 #else
190
191 static inline
192 unsigned short swap_cgroup_record(swp_entry_t ent, unsigned short id)
193 {
194         return 0;
195 }
196
197 static inline
198 unsigned short lookup_swap_cgroup(swp_entry_t ent)
199 {
200         return 0;
201 }
202
203 static inline int
204 swap_cgroup_swapon(int type, unsigned long max_pages)
205 {
206         return 0;
207 }
208
209 static inline void swap_cgroup_swapoff(int type)
210 {
211         return;
212 }
213
214 #endif /* CONFIG_CGROUP_MEM_RES_CTLR_SWAP */
215
216 #endif /* !__GENERATING_BOUNDS_H */
217
218 #endif /* __LINUX_PAGE_CGROUP_H */