Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * NUMA memory policies for Linux.
4 * Copyright 2003,2004 Andi Kleen SuSE Labs
5 */
6#ifndef _LINUX_MEMPOLICY_H
7#define _LINUX_MEMPOLICY_H 1
8
9#include <linux/sched.h>
10#include <linux/mmzone.h>
11#include <linux/slab.h>
12#include <linux/rbtree.h>
13#include <linux/spinlock.h>
14#include <linux/node.h>
15#include <linux/nodemask.h>
16#include <linux/pagemap.h>
17#include <uapi/linux/mempolicy.h>
18
19struct mm_struct;
20
21#define NO_INTERLEAVE_INDEX (-1UL) /* use task il_prev for interleaving */
22
23#ifdef CONFIG_NUMA
24
25/*
26 * Describe a memory policy.
27 *
28 * A mempolicy can be either associated with a process or with a VMA.
29 * For VMA related allocations the VMA policy is preferred, otherwise
30 * the process policy is used. Interrupts ignore the memory policy
31 * of the current process.
32 *
33 * Locking policy for interleave:
34 * In process context there is no locking because only the process accesses
35 * its own state. All vma manipulation is somewhat protected by a down_read on
36 * mmap_lock.
37 *
38 * Freeing policy:
39 * Mempolicy objects are reference counted. A mempolicy will be freed when
40 * mpol_put() decrements the reference count to zero.
41 *
42 * Duplicating policy objects:
43 * mpol_dup() allocates a new mempolicy and copies the specified mempolicy
44 * to the new storage. The reference count of the new object is initialized
45 * to 1, representing the caller of mpol_dup().
46 */
47struct mempolicy {
48 atomic_t refcnt;
49 unsigned short mode; /* See MPOL_* above */
50 unsigned short flags; /* See set_mempolicy() MPOL_F_* above */
51 nodemask_t nodes; /* interleave/bind/preferred/etc */
52 int home_node; /* Home node to use for MPOL_BIND and MPOL_PREFERRED_MANY */
53
54 union {
55 nodemask_t cpuset_mems_allowed; /* relative to these nodes */
56 nodemask_t user_nodemask; /* nodemask passed by user */
57 } w;
58 struct rcu_head rcu;
59};
60
61/*
62 * Support for managing mempolicy data objects (clone, copy, destroy)
63 * The default fast path of a NULL MPOL_DEFAULT policy is always inlined.
64 */
65
66extern void __mpol_put(struct mempolicy *pol);
67static inline void mpol_put(struct mempolicy *pol)
68{
69 if (pol)
70 __mpol_put(pol);
71}
72
73/*
74 * Does mempolicy pol need explicit unref after use?
75 * Currently only needed for shared policies.
76 */
77static inline int mpol_needs_cond_ref(struct mempolicy *pol)
78{
79 return (pol && (pol->flags & MPOL_F_SHARED));
80}
81
82static inline void mpol_cond_put(struct mempolicy *pol)
83{
84 if (mpol_needs_cond_ref(pol))
85 __mpol_put(pol);
86}
87
88extern struct mempolicy *__mpol_dup(struct mempolicy *pol);
89static inline struct mempolicy *mpol_dup(struct mempolicy *pol)
90{
91 if (pol)
92 pol = __mpol_dup(pol);
93 return pol;
94}
95
96static inline void mpol_get(struct mempolicy *pol)
97{
98 if (pol)
99 atomic_inc(&pol->refcnt);
100}
101
102extern bool __mpol_equal(struct mempolicy *a, struct mempolicy *b);
103static 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 */
113struct shared_policy {
114 struct rb_root root;
115 rwlock_t lock;
116};
117struct sp_node {
118 struct rb_node nd;
119 pgoff_t start, end;
120 struct mempolicy *policy;
121};
122
123int vma_dup_policy(struct vm_area_struct *src, struct vm_area_struct *dst);
124void mpol_shared_policy_init(struct shared_policy *sp, struct mempolicy *mpol);
125int mpol_set_shared_policy(struct shared_policy *sp,
126 struct vm_area_struct *vma, struct mempolicy *mpol);
127void mpol_free_shared_policy(struct shared_policy *sp);
128struct mempolicy *mpol_shared_policy_lookup(struct shared_policy *sp,
129 pgoff_t idx);
130
131struct mempolicy *get_task_policy(struct task_struct *p);
132struct mempolicy *__get_vma_policy(struct vm_area_struct *vma,
133 unsigned long addr, pgoff_t *ilx);
134struct mempolicy *get_vma_policy(struct vm_area_struct *vma,
135 unsigned long addr, int order, pgoff_t *ilx);
136bool vma_policy_mof(struct vm_area_struct *vma);
137
138extern void numa_default_policy(void);
139extern void numa_policy_init(void);
140extern void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new);
141extern void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new);
142
143extern int huge_node(struct vm_area_struct *vma,
144 unsigned long addr, gfp_t gfp_flags,
145 struct mempolicy **mpol, nodemask_t **nodemask);
146extern bool init_nodemask_of_mempolicy(nodemask_t *mask);
147extern bool mempolicy_in_oom_domain(struct task_struct *tsk,
148 const nodemask_t *mask);
149extern unsigned int mempolicy_slab_node(void);
150
151extern enum zone_type policy_zone;
152
153static inline void check_highest_zone(enum zone_type k)
154{
155 if (k > policy_zone && k != ZONE_MOVABLE)
156 policy_zone = k;
157}
158
159int do_migrate_pages(struct mm_struct *mm, const nodemask_t *from,
160 const nodemask_t *to, int flags);
161
162
163#ifdef CONFIG_TMPFS
164extern int mpol_parse_str(char *str, struct mempolicy **mpol);
165#endif
166
167extern void mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol);
168
169/* Check if a vma is migratable */
170extern bool vma_migratable(struct vm_area_struct *vma);
171
172int mpol_misplaced(struct folio *folio, struct vm_fault *vmf,
173 unsigned long addr);
174extern void mpol_put_task_policy(struct task_struct *);
175
176static inline bool mpol_is_preferred_many(struct mempolicy *pol)
177{
178 return (pol->mode == MPOL_PREFERRED_MANY);
179}
180
181extern bool apply_policy_zone(struct mempolicy *policy, enum zone_type zone);
182
183extern int mempolicy_set_node_perf(unsigned int node,
184 struct access_coordinate *coords);
185
186#else
187
188struct mempolicy {};
189
190static inline struct mempolicy *get_task_policy(struct task_struct *p)
191{
192 return NULL;
193}
194
195static inline bool mpol_equal(struct mempolicy *a, struct mempolicy *b)
196{
197 return true;
198}
199
200static inline void mpol_put(struct mempolicy *pol)
201{
202}
203
204static inline void mpol_cond_put(struct mempolicy *pol)
205{
206}
207
208static inline void mpol_get(struct mempolicy *pol)
209{
210}
211
212struct shared_policy {};
213
214static inline void mpol_shared_policy_init(struct shared_policy *sp,
215 struct mempolicy *mpol)
216{
217}
218
219static inline void mpol_free_shared_policy(struct shared_policy *sp)
220{
221}
222
223static inline struct mempolicy *
224mpol_shared_policy_lookup(struct shared_policy *sp, pgoff_t idx)
225{
226 return NULL;
227}
228
229static inline struct mempolicy *get_vma_policy(struct vm_area_struct *vma,
230 unsigned long addr, int order, pgoff_t *ilx)
231{
232 *ilx = 0;
233 return NULL;
234}
235
236static inline int
237vma_dup_policy(struct vm_area_struct *src, struct vm_area_struct *dst)
238{
239 return 0;
240}
241
242static inline void numa_policy_init(void)
243{
244}
245
246static inline void numa_default_policy(void)
247{
248}
249
250static inline void mpol_rebind_task(struct task_struct *tsk,
251 const nodemask_t *new)
252{
253}
254
255static inline void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new)
256{
257}
258
259static inline int huge_node(struct vm_area_struct *vma,
260 unsigned long addr, gfp_t gfp_flags,
261 struct mempolicy **mpol, nodemask_t **nodemask)
262{
263 *mpol = NULL;
264 *nodemask = NULL;
265 return 0;
266}
267
268static inline bool init_nodemask_of_mempolicy(nodemask_t *m)
269{
270 return false;
271}
272
273static inline int do_migrate_pages(struct mm_struct *mm, const nodemask_t *from,
274 const nodemask_t *to, int flags)
275{
276 return 0;
277}
278
279static inline void check_highest_zone(int k)
280{
281}
282
283#ifdef CONFIG_TMPFS
284static inline int mpol_parse_str(char *str, struct mempolicy **mpol)
285{
286 return 1; /* error */
287}
288#endif
289
290static inline int mpol_misplaced(struct folio *folio,
291 struct vm_fault *vmf,
292 unsigned long address)
293{
294 return -1; /* no node preference */
295}
296
297static inline void mpol_put_task_policy(struct task_struct *task)
298{
299}
300
301static inline bool mpol_is_preferred_many(struct mempolicy *pol)
302{
303 return false;
304}
305
306#endif /* CONFIG_NUMA */
307#endif