Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mempolicy.h
Go to the documentation of this file.
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_dup(struct mempolicy *pol);
86 static inline struct mempolicy *mpol_dup(struct mempolicy *pol)
87 {
88  if (pol)
89  pol = __mpol_dup(pol);
90  return pol;
91 }
92 
93 #define vma_policy(vma) ((vma)->vm_policy)
94 #define vma_set_policy(vma, pol) ((vma)->vm_policy = (pol))
95 
96 static inline void mpol_get(struct mempolicy *pol)
97 {
98  if (pol)
99  atomic_inc(&pol->refcnt);
100 }
101 
102 extern bool __mpol_equal(struct mempolicy *a, struct mempolicy *b);
103 static inline bool mpol_equal(struct mempolicy *a, struct mempolicy *b)
104 {
105  if (a == b)
106  return true;
107  return __mpol_equal(a, b);
108 }
109 
110 /*
111  * Tree of shared policies for a shared memory region.
112  * Maintain the policies in a pseudo mm that contains vmas. The vmas
113  * carry the policy. As a special twist the pseudo mm is indexed in pages, not
114  * bytes, so that we can work with shared memory segments bigger than
115  * unsigned long.
116  */
117 
118 struct sp_node {
119  struct rb_node nd;
120  unsigned long start, end;
121  struct mempolicy *policy;
122 };
123 
124 struct shared_policy {
125  struct rb_root root;
126  struct mutex mutex;
127 };
128 
129 void mpol_shared_policy_init(struct shared_policy *sp, struct mempolicy *mpol);
131  struct vm_area_struct *vma,
132  struct mempolicy *new);
135  unsigned long idx);
136 
137 struct mempolicy *get_vma_policy(struct task_struct *tsk,
138  struct vm_area_struct *vma, unsigned long addr);
139 
140 extern void numa_default_policy(void);
141 extern void numa_policy_init(void);
142 extern void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new,
143  enum mpol_rebind_step step);
144 extern void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new);
145 extern void mpol_fix_fork_child_flag(struct task_struct *p);
146 
147 extern struct zonelist *huge_zonelist(struct vm_area_struct *vma,
148  unsigned long addr, gfp_t gfp_flags,
149  struct mempolicy **mpol, nodemask_t **nodemask);
150 extern bool init_nodemask_of_mempolicy(nodemask_t *mask);
151 extern bool mempolicy_nodemask_intersects(struct task_struct *tsk,
152  const nodemask_t *mask);
153 extern unsigned slab_node(void);
154 
155 extern enum zone_type policy_zone;
156 
157 static inline void check_highest_zone(enum zone_type k)
158 {
159  if (k > policy_zone && k != ZONE_MOVABLE)
160  policy_zone = k;
161 }
162 
163 int do_migrate_pages(struct mm_struct *mm, const nodemask_t *from,
164  const nodemask_t *to, int flags);
165 
166 
167 #ifdef CONFIG_TMPFS
168 extern int mpol_parse_str(char *str, struct mempolicy **mpol, int no_context);
169 #endif
170 
171 extern int mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol,
172  int no_context);
173 
174 /* Check if a vma is migratable */
175 static inline int vma_migratable(struct vm_area_struct *vma)
176 {
177  if (vma->vm_flags & (VM_IO | VM_HUGETLB | VM_PFNMAP))
178  return 0;
179  /*
180  * Migration allocates pages in the highest zone. If we cannot
181  * do so then migration (at least from node to node) is not
182  * possible.
183  */
184  if (vma->vm_file &&
185  gfp_zone(mapping_gfp_mask(vma->vm_file->f_mapping))
186  < policy_zone)
187  return 0;
188  return 1;
189 }
190 
191 #else
192 
193 struct mempolicy {};
194 
195 static inline bool mpol_equal(struct mempolicy *a, struct mempolicy *b)
196 {
197  return true;
198 }
199 
200 static inline void mpol_put(struct mempolicy *p)
201 {
202 }
203 
204 static inline void mpol_cond_put(struct mempolicy *pol)
205 {
206 }
207 
208 static inline void mpol_get(struct mempolicy *pol)
209 {
210 }
211 
212 static inline struct mempolicy *mpol_dup(struct mempolicy *old)
213 {
214  return NULL;
215 }
216 
217 struct shared_policy {};
218 
219 static inline int mpol_set_shared_policy(struct shared_policy *info,
220  struct vm_area_struct *vma,
221  struct mempolicy *new)
222 {
223  return -EINVAL;
224 }
225 
226 static inline void mpol_shared_policy_init(struct shared_policy *sp,
227  struct mempolicy *mpol)
228 {
229 }
230 
231 static inline void mpol_free_shared_policy(struct shared_policy *p)
232 {
233 }
234 
235 static inline struct mempolicy *
236 mpol_shared_policy_lookup(struct shared_policy *sp, unsigned long idx)
237 {
238  return NULL;
239 }
240 
241 #define vma_policy(vma) NULL
242 #define vma_set_policy(vma, pol) do {} while(0)
243 
244 static inline void numa_policy_init(void)
245 {
246 }
247 
248 static inline void numa_default_policy(void)
249 {
250 }
251 
252 static inline void mpol_rebind_task(struct task_struct *tsk,
253  const nodemask_t *new,
254  enum mpol_rebind_step step)
255 {
256 }
257 
258 static inline void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new)
259 {
260 }
261 
262 static inline void mpol_fix_fork_child_flag(struct task_struct *p)
263 {
264 }
265 
266 static inline struct zonelist *huge_zonelist(struct vm_area_struct *vma,
267  unsigned long addr, gfp_t gfp_flags,
268  struct mempolicy **mpol, nodemask_t **nodemask)
269 {
270  *mpol = NULL;
271  *nodemask = NULL;
272  return node_zonelist(0, gfp_flags);
273 }
274 
275 static inline bool init_nodemask_of_mempolicy(nodemask_t *m)
276 {
277  return false;
278 }
279 
280 static inline bool mempolicy_nodemask_intersects(struct task_struct *tsk,
281  const nodemask_t *mask)
282 {
283  return false;
284 }
285 
286 static inline int do_migrate_pages(struct mm_struct *mm, const nodemask_t *from,
287  const nodemask_t *to, int flags)
288 {
289  return 0;
290 }
291 
292 static inline void check_highest_zone(int k)
293 {
294 }
295 
296 #ifdef CONFIG_TMPFS
297 static inline int mpol_parse_str(char *str, struct mempolicy **mpol,
298  int no_context)
299 {
300  return 1; /* error */
301 }
302 #endif
303 
304 static inline int mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol,
305  int no_context)
306 {
307  return 0;
308 }
309 
310 #endif /* CONFIG_NUMA */
311 #endif