]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - include/linux/mempolicy.h
e5ccb9ddd90eeb634665e88afd13d56184fff241
[~shefty/rdma-dev.git] / include / linux / mempolicy.h
1 /*
2  * NUMA memory policies for Linux.
3  * Copyright 2003,2004 Andi Kleen SuSE Labs
4  */
5 #ifndef _LINUX_MEMPOLICY_H
6 #define _LINUX_MEMPOLICY_H 1
7
8
9 #include <linux/mmzone.h>
10 #include <linux/slab.h>
11 #include <linux/rbtree.h>
12 #include <linux/spinlock.h>
13 #include <linux/nodemask.h>
14 #include <linux/pagemap.h>
15 #include <uapi/linux/mempolicy.h>
16
17 struct mm_struct;
18
19 #ifdef CONFIG_NUMA
20
21 /*
22  * Describe a memory policy.
23  *
24  * A mempolicy can be either associated with a process or with a VMA.
25  * For VMA related allocations the VMA policy is preferred, otherwise
26  * the process policy is used. Interrupts ignore the memory policy
27  * of the current process.
28  *
29  * Locking policy for interlave:
30  * In process context there is no locking because only the process accesses
31  * its own state. All vma manipulation is somewhat protected by a down_read on
32  * mmap_sem.
33  *
34  * Freeing policy:
35  * Mempolicy objects are reference counted.  A mempolicy will be freed when
36  * mpol_put() decrements the reference count to zero.
37  *
38  * Duplicating policy objects:
39  * mpol_dup() allocates a new mempolicy and copies the specified mempolicy
40  * to the new storage.  The reference count of the new object is initialized
41  * to 1, representing the caller of mpol_dup().
42  */
43 struct mempolicy {
44         atomic_t refcnt;
45         unsigned short mode;    /* See MPOL_* above */
46         unsigned short flags;   /* See set_mempolicy() MPOL_F_* above */
47         union {
48                 short            preferred_node; /* preferred */
49                 nodemask_t       nodes;         /* interleave/bind */
50                 /* undefined for default */
51         } v;
52         union {
53                 nodemask_t cpuset_mems_allowed; /* relative to these nodes */
54                 nodemask_t user_nodemask;       /* nodemask passed by user */
55         } w;
56 };
57
58 /*
59  * Support for managing mempolicy data objects (clone, copy, destroy)
60  * The default fast path of a NULL MPOL_DEFAULT policy is always inlined.
61  */
62
63 extern void __mpol_put(struct mempolicy *pol);
64 static inline void mpol_put(struct mempolicy *pol)
65 {
66         if (pol)
67                 __mpol_put(pol);
68 }
69
70 /*
71  * Does mempolicy pol need explicit unref after use?
72  * Currently only needed for shared policies.
73  */
74 static inline int mpol_needs_cond_ref(struct mempolicy *pol)
75 {
76         return (pol && (pol->flags & MPOL_F_SHARED));
77 }
78
79 static inline void mpol_cond_put(struct mempolicy *pol)
80 {
81         if (mpol_needs_cond_ref(pol))
82                 __mpol_put(pol);
83 }
84
85 extern struct mempolicy *__mpol_cond_copy(struct mempolicy *tompol,
86                                           struct mempolicy *frompol);
87 static inline struct mempolicy *mpol_cond_copy(struct mempolicy *tompol,
88                                                 struct mempolicy *frompol)
89 {
90         if (!frompol)
91                 return frompol;
92         return __mpol_cond_copy(tompol, frompol);
93 }
94
95 extern struct mempolicy *__mpol_dup(struct mempolicy *pol);
96 static inline struct mempolicy *mpol_dup(struct mempolicy *pol)
97 {
98         if (pol)
99                 pol = __mpol_dup(pol);
100         return pol;
101 }
102
103 #define vma_policy(vma) ((vma)->vm_policy)
104 #define vma_set_policy(vma, pol) ((vma)->vm_policy = (pol))
105
106 static inline void mpol_get(struct mempolicy *pol)
107 {
108         if (pol)
109                 atomic_inc(&pol->refcnt);
110 }
111
112 extern bool __mpol_equal(struct mempolicy *a, struct mempolicy *b);
113 static inline bool mpol_equal(struct mempolicy *a, struct mempolicy *b)
114 {
115         if (a == b)
116                 return true;
117         return __mpol_equal(a, b);
118 }
119
120 /*
121  * Tree of shared policies for a shared memory region.
122  * Maintain the policies in a pseudo mm that contains vmas. The vmas
123  * carry the policy. As a special twist the pseudo mm is indexed in pages, not
124  * bytes, so that we can work with shared memory segments bigger than
125  * unsigned long.
126  */
127
128 struct sp_node {
129         struct rb_node nd;
130         unsigned long start, end;
131         struct mempolicy *policy;
132 };
133
134 struct shared_policy {
135         struct rb_root root;
136         struct mutex mutex;
137 };
138
139 void mpol_shared_policy_init(struct shared_policy *sp, struct mempolicy *mpol);
140 int mpol_set_shared_policy(struct shared_policy *info,
141                                 struct vm_area_struct *vma,
142                                 struct mempolicy *new);
143 void mpol_free_shared_policy(struct shared_policy *p);
144 struct mempolicy *mpol_shared_policy_lookup(struct shared_policy *sp,
145                                             unsigned long idx);
146
147 struct mempolicy *get_vma_policy(struct task_struct *tsk,
148                 struct vm_area_struct *vma, unsigned long addr);
149
150 extern void numa_default_policy(void);
151 extern void numa_policy_init(void);
152 extern void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new,
153                                 enum mpol_rebind_step step);
154 extern void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new);
155 extern void mpol_fix_fork_child_flag(struct task_struct *p);
156
157 extern struct zonelist *huge_zonelist(struct vm_area_struct *vma,
158                                 unsigned long addr, gfp_t gfp_flags,
159                                 struct mempolicy **mpol, nodemask_t **nodemask);
160 extern bool init_nodemask_of_mempolicy(nodemask_t *mask);
161 extern bool mempolicy_nodemask_intersects(struct task_struct *tsk,
162                                 const nodemask_t *mask);
163 extern unsigned slab_node(void);
164
165 extern enum zone_type policy_zone;
166
167 static inline void check_highest_zone(enum zone_type k)
168 {
169         if (k > policy_zone && k != ZONE_MOVABLE)
170                 policy_zone = k;
171 }
172
173 int do_migrate_pages(struct mm_struct *mm, const nodemask_t *from,
174                      const nodemask_t *to, int flags);
175
176
177 #ifdef CONFIG_TMPFS
178 extern int mpol_parse_str(char *str, struct mempolicy **mpol, int no_context);
179 #endif
180
181 extern int mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol,
182                         int no_context);
183
184 /* Check if a vma is migratable */
185 static inline int vma_migratable(struct vm_area_struct *vma)
186 {
187         if (vma->vm_flags & (VM_IO | VM_HUGETLB | VM_PFNMAP))
188                 return 0;
189         /*
190          * Migration allocates pages in the highest zone. If we cannot
191          * do so then migration (at least from node to node) is not
192          * possible.
193          */
194         if (vma->vm_file &&
195                 gfp_zone(mapping_gfp_mask(vma->vm_file->f_mapping))
196                                                                 < policy_zone)
197                         return 0;
198         return 1;
199 }
200
201 #else
202
203 struct mempolicy {};
204
205 static inline bool mpol_equal(struct mempolicy *a, struct mempolicy *b)
206 {
207         return true;
208 }
209
210 static inline void mpol_put(struct mempolicy *p)
211 {
212 }
213
214 static inline void mpol_cond_put(struct mempolicy *pol)
215 {
216 }
217
218 static inline struct mempolicy *mpol_cond_copy(struct mempolicy *to,
219                                                 struct mempolicy *from)
220 {
221         return from;
222 }
223
224 static inline void mpol_get(struct mempolicy *pol)
225 {
226 }
227
228 static inline struct mempolicy *mpol_dup(struct mempolicy *old)
229 {
230         return NULL;
231 }
232
233 struct shared_policy {};
234
235 static inline int mpol_set_shared_policy(struct shared_policy *info,
236                                         struct vm_area_struct *vma,
237                                         struct mempolicy *new)
238 {
239         return -EINVAL;
240 }
241
242 static inline void mpol_shared_policy_init(struct shared_policy *sp,
243                                                 struct mempolicy *mpol)
244 {
245 }
246
247 static inline void mpol_free_shared_policy(struct shared_policy *p)
248 {
249 }
250
251 static inline struct mempolicy *
252 mpol_shared_policy_lookup(struct shared_policy *sp, unsigned long idx)
253 {
254         return NULL;
255 }
256
257 #define vma_policy(vma) NULL
258 #define vma_set_policy(vma, pol) do {} while(0)
259
260 static inline void numa_policy_init(void)
261 {
262 }
263
264 static inline void numa_default_policy(void)
265 {
266 }
267
268 static inline void mpol_rebind_task(struct task_struct *tsk,
269                                 const nodemask_t *new,
270                                 enum mpol_rebind_step step)
271 {
272 }
273
274 static inline void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new)
275 {
276 }
277
278 static inline void mpol_fix_fork_child_flag(struct task_struct *p)
279 {
280 }
281
282 static inline struct zonelist *huge_zonelist(struct vm_area_struct *vma,
283                                 unsigned long addr, gfp_t gfp_flags,
284                                 struct mempolicy **mpol, nodemask_t **nodemask)
285 {
286         *mpol = NULL;
287         *nodemask = NULL;
288         return node_zonelist(0, gfp_flags);
289 }
290
291 static inline bool init_nodemask_of_mempolicy(nodemask_t *m)
292 {
293         return false;
294 }
295
296 static inline bool mempolicy_nodemask_intersects(struct task_struct *tsk,
297                         const nodemask_t *mask)
298 {
299         return false;
300 }
301
302 static inline int do_migrate_pages(struct mm_struct *mm, const nodemask_t *from,
303                                    const nodemask_t *to, int flags)
304 {
305         return 0;
306 }
307
308 static inline void check_highest_zone(int k)
309 {
310 }
311
312 #ifdef CONFIG_TMPFS
313 static inline int mpol_parse_str(char *str, struct mempolicy **mpol,
314                                 int no_context)
315 {
316         return 1;       /* error */
317 }
318 #endif
319
320 static inline int mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol,
321                                 int no_context)
322 {
323         return 0;
324 }
325
326 #endif /* CONFIG_NUMA */
327 #endif