Blame view
include/linux/gfp.h
24.4 KB
b24413180 License cleanup: ... |
1 |
/* SPDX-License-Identifier: GPL-2.0 */ |
1da177e4c Linux-2.6.12-rc2 |
2 3 |
#ifndef __LINUX_GFP_H #define __LINUX_GFP_H |
309381fea mm: dump page whe... |
4 |
#include <linux/mmdebug.h> |
1da177e4c Linux-2.6.12-rc2 |
5 6 7 |
#include <linux/mmzone.h> #include <linux/stddef.h> #include <linux/linkage.h> |
082edb7bf numa, cpumask: mo... |
8 |
#include <linux/topology.h> |
1da177e4c Linux-2.6.12-rc2 |
9 10 |
struct vm_area_struct; |
1f7866b4a mm, tracing: make... |
11 12 |
/* * In case of changes, please don't forget to update |
420adbe9f mm, tracing: unif... |
13 |
* include/trace/events/mmflags.h and tools/perf/builtin-kmem.c |
1f7866b4a mm, tracing: make... |
14 |
*/ |
16b56cf4b mm: fix sparse wa... |
15 16 17 18 19 |
/* Plain integer GFP bitmasks. Do not use this directly. */ #define ___GFP_DMA 0x01u #define ___GFP_HIGHMEM 0x02u #define ___GFP_DMA32 0x04u #define ___GFP_MOVABLE 0x08u |
016c13daa mm, page_alloc: u... |
20 |
#define ___GFP_RECLAIMABLE 0x10u |
16b56cf4b mm: fix sparse wa... |
21 22 23 |
#define ___GFP_HIGH 0x20u #define ___GFP_IO 0x40u #define ___GFP_FS 0x80u |
d71e53cee mm: shuffle GFP_*... |
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
#define ___GFP_ZERO 0x100u #define ___GFP_ATOMIC 0x200u #define ___GFP_DIRECT_RECLAIM 0x400u #define ___GFP_KSWAPD_RECLAIM 0x800u #define ___GFP_WRITE 0x1000u #define ___GFP_NOWARN 0x2000u #define ___GFP_RETRY_MAYFAIL 0x4000u #define ___GFP_NOFAIL 0x8000u #define ___GFP_NORETRY 0x10000u #define ___GFP_MEMALLOC 0x20000u #define ___GFP_COMP 0x40000u #define ___GFP_NOMEMALLOC 0x80000u #define ___GFP_HARDWALL 0x100000u #define ___GFP_THISNODE 0x200000u #define ___GFP_ACCOUNT 0x400000u |
7ff00a49a ANDROID: cma: red... |
39 40 41 42 43 |
#ifdef CONFIG_CMA #define ___GFP_CMA 0x800000u #else #define ___GFP_CMA 0 #endif |
7e7844226 lockdep: allow to... |
44 |
#ifdef CONFIG_LOCKDEP |
7ff00a49a ANDROID: cma: red... |
45 46 47 |
#ifdef CONFIG_CMA #define ___GFP_NOLOCKDEP 0x1000000u #else |
e67d4ca79 mm: save two stra... |
48 |
#define ___GFP_NOLOCKDEP 0x800000u |
7ff00a49a ANDROID: cma: red... |
49 |
#endif |
7e7844226 lockdep: allow to... |
50 51 52 |
#else #define ___GFP_NOLOCKDEP 0 #endif |
7ff00a49a ANDROID: cma: red... |
53 |
|
05b0afd73 mm: add a reminde... |
54 |
/* If the above are modified, __GFP_BITS_SHIFT may need updating */ |
16b56cf4b mm: fix sparse wa... |
55 |
|
1da177e4c Linux-2.6.12-rc2 |
56 |
/* |
dd56b0464 mm: page_alloc: h... |
57 |
* Physical address zone modifiers (see linux/mmzone.h - low four bits) |
e53ef38d0 [PATCH] reduce MA... |
58 |
* |
e53ef38d0 [PATCH] reduce MA... |
59 |
* Do not put any conditional on these. If necessary modify the definitions |
263ff5d8e include/linux/gfp... |
60 |
* without the underscores and use them consistently. The definitions here may |
e53ef38d0 [PATCH] reduce MA... |
61 |
* be used in bit comparisons. |
1da177e4c Linux-2.6.12-rc2 |
62 |
*/ |
16b56cf4b mm: fix sparse wa... |
63 64 65 |
#define __GFP_DMA ((__force gfp_t)___GFP_DMA) #define __GFP_HIGHMEM ((__force gfp_t)___GFP_HIGHMEM) #define __GFP_DMA32 ((__force gfp_t)___GFP_DMA32) |
dd56b0464 mm: page_alloc: h... |
66 |
#define __GFP_MOVABLE ((__force gfp_t)___GFP_MOVABLE) /* ZONE_MOVABLE allowed */ |
7ff00a49a ANDROID: cma: red... |
67 |
#define __GFP_CMA ((__force gfp_t)___GFP_CMA) |
b70d94ee4 page-allocator: u... |
68 |
#define GFP_ZONEMASK (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE) |
dd56b0464 mm: page_alloc: h... |
69 |
|
263fade51 docs/mm: make GFP... |
70 71 72 |
/** * DOC: Page mobility and placement hints * |
dd56b0464 mm: page_alloc: h... |
73 |
* Page mobility and placement hints |
263fade51 docs/mm: make GFP... |
74 |
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
1da177e4c Linux-2.6.12-rc2 |
75 |
* |
dd56b0464 mm: page_alloc: h... |
76 77 78 |
* These flags provide hints about how mobile the page is. Pages with similar * mobility are placed within the same pageblocks to minimise problems due * to external fragmentation. |
1da177e4c Linux-2.6.12-rc2 |
79 |
* |
263fade51 docs/mm: make GFP... |
80 81 |
* %__GFP_MOVABLE (also a zone modifier) indicates that the page can be * moved by page migration during memory compaction or can be reclaimed. |
1da177e4c Linux-2.6.12-rc2 |
82 |
* |
263fade51 docs/mm: make GFP... |
83 84 |
* %__GFP_RECLAIMABLE is used for slab allocations that specify * SLAB_RECLAIM_ACCOUNT and whose pages can be freed via shrinkers. |
dd56b0464 mm: page_alloc: h... |
85 |
* |
263fade51 docs/mm: make GFP... |
86 87 88 |
* %__GFP_WRITE indicates the caller intends to dirty the page. Where possible, * these pages will be spread between local zones to avoid all the dirty * pages being in one zone (fair zone allocation policy). |
769848c03 Add __GFP_MOVABLE... |
89 |
* |
263fade51 docs/mm: make GFP... |
90 |
* %__GFP_HARDWALL enforces the cpuset memory allocation policy. |
dd56b0464 mm: page_alloc: h... |
91 |
* |
70c6066e1 include/linux/gfp... |
92 |
* %__GFP_THISNODE forces the allocation to be satisfied from the requested |
263fade51 docs/mm: make GFP... |
93 |
* node with no fallbacks or placement policy enforcements. |
a9bb7e620 memcg: only accou... |
94 |
* |
263fade51 docs/mm: make GFP... |
95 |
* %__GFP_ACCOUNT causes the allocation to be accounted to kmemcg. |
1da177e4c Linux-2.6.12-rc2 |
96 |
*/ |
dd56b0464 mm: page_alloc: h... |
97 98 99 100 |
#define __GFP_RECLAIMABLE ((__force gfp_t)___GFP_RECLAIMABLE) #define __GFP_WRITE ((__force gfp_t)___GFP_WRITE) #define __GFP_HARDWALL ((__force gfp_t)___GFP_HARDWALL) #define __GFP_THISNODE ((__force gfp_t)___GFP_THISNODE) |
a9bb7e620 memcg: only accou... |
101 |
#define __GFP_ACCOUNT ((__force gfp_t)___GFP_ACCOUNT) |
32dba98e0 thp: _GFP_NO_KSWAPD |
102 |
|
263fade51 docs/mm: make GFP... |
103 104 105 |
/** * DOC: Watermark modifiers * |
dd56b0464 mm: page_alloc: h... |
106 |
* Watermark modifiers -- controls access to emergency reserves |
263fade51 docs/mm: make GFP... |
107 |
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
dd56b0464 mm: page_alloc: h... |
108 |
* |
263fade51 docs/mm: make GFP... |
109 110 111 |
* %__GFP_HIGH indicates that the caller is high-priority and that granting * the request is necessary before the system can make forward progress. * For example, creating an IO context to clean pages. |
dd56b0464 mm: page_alloc: h... |
112 |
* |
263fade51 docs/mm: make GFP... |
113 114 115 |
* %__GFP_ATOMIC indicates that the caller cannot reclaim or sleep and is * high priority. Users are typically interrupt handlers. This may be * used in conjunction with %__GFP_HIGH |
dd56b0464 mm: page_alloc: h... |
116 |
* |
263fade51 docs/mm: make GFP... |
117 118 119 120 |
* %__GFP_MEMALLOC allows access to all memory. This should only be used when * the caller guarantees the allocation will allow more memory to be freed * very shortly e.g. process exiting or swapping. Users either should * be the MM or co-ordinating closely with the VM (e.g. swap over NFS). |
574c1ae66 mm: clarify __GFP... |
121 122 123 124 125 |
* Users of this flag have to be extremely careful to not deplete the reserve * completely and implement a throttling mechanism which controls the * consumption of the reserve based on the amount of freed memory. * Usage of a pre-allocated pool (e.g. mempool) should be always considered * before using this flag. |
dd56b0464 mm: page_alloc: h... |
126 |
* |
263fade51 docs/mm: make GFP... |
127 128 |
* %__GFP_NOMEMALLOC is used to explicitly forbid access to emergency reserves. * This takes precedence over the %__GFP_MEMALLOC flag if both are set. |
d0164adc8 mm, page_alloc: d... |
129 |
*/ |
dd56b0464 mm: page_alloc: h... |
130 131 132 133 |
#define __GFP_ATOMIC ((__force gfp_t)___GFP_ATOMIC) #define __GFP_HIGH ((__force gfp_t)___GFP_HIGH) #define __GFP_MEMALLOC ((__force gfp_t)___GFP_MEMALLOC) #define __GFP_NOMEMALLOC ((__force gfp_t)___GFP_NOMEMALLOC) |
dd56b0464 mm: page_alloc: h... |
134 |
|
263fade51 docs/mm: make GFP... |
135 136 137 |
/** * DOC: Reclaim modifiers * |
dd56b0464 mm: page_alloc: h... |
138 |
* Reclaim modifiers |
263fade51 docs/mm: make GFP... |
139 |
* ~~~~~~~~~~~~~~~~~ |
29fd18970 mm: make it clear... |
140 141 |
* Please note that all the following flags are only applicable to sleepable * allocations (e.g. %GFP_NOWAIT and %GFP_ATOMIC will ignore them). |
dd56b0464 mm: page_alloc: h... |
142 |
* |
263fade51 docs/mm: make GFP... |
143 |
* %__GFP_IO can start physical IO. |
dd56b0464 mm: page_alloc: h... |
144 |
* |
263fade51 docs/mm: make GFP... |
145 146 147 |
* %__GFP_FS can call down to the low-level FS. Clearing the flag avoids the * allocator recursing into the filesystem which might already be holding * locks. |
dd56b0464 mm: page_alloc: h... |
148 |
* |
263fade51 docs/mm: make GFP... |
149 150 151 |
* %__GFP_DIRECT_RECLAIM indicates that the caller may enter direct reclaim. * This flag can be cleared to avoid unnecessary delays when a fallback * option is available. |
dd56b0464 mm: page_alloc: h... |
152 |
* |
263fade51 docs/mm: make GFP... |
153 154 155 156 157 158 |
* %__GFP_KSWAPD_RECLAIM indicates that the caller wants to wake kswapd when * the low watermark is reached and have it reclaim pages until the high * watermark is reached. A caller may wish to clear this flag when fallback * options are available and the reclaim is likely to disrupt the system. The * canonical example is THP allocation where a fallback is cheap but * reclaim/compaction may cause indirect stalls. |
dd56b0464 mm: page_alloc: h... |
159 |
* |
263fade51 docs/mm: make GFP... |
160 |
* %__GFP_RECLAIM is shorthand to allow/forbid both direct and kswapd reclaim. |
dd56b0464 mm: page_alloc: h... |
161 |
* |
dcda9b047 mm, tree wide: re... |
162 |
* The default allocator behavior depends on the request size. We have a concept |
263fade51 docs/mm: make GFP... |
163 |
* of so called costly allocations (with order > %PAGE_ALLOC_COSTLY_ORDER). |
dcda9b047 mm, tree wide: re... |
164 165 166 167 168 169 170 |
* !costly allocations are too essential to fail so they are implicitly * non-failing by default (with some exceptions like OOM victims might fail so * the caller still has to check for failures) while costly requests try to be * not disruptive and back off even without invoking the OOM killer. * The following three modifiers might be used to override some of these * implicit rules * |
263fade51 docs/mm: make GFP... |
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 |
* %__GFP_NORETRY: The VM implementation will try only very lightweight * memory direct reclaim to get some memory under memory pressure (thus * it can sleep). It will avoid disruptive actions like OOM killer. The * caller must handle the failure which is quite likely to happen under * heavy memory pressure. The flag is suitable when failure can easily be * handled at small cost, such as reduced throughput * * %__GFP_RETRY_MAYFAIL: The VM implementation will retry memory reclaim * procedures that have previously failed if there is some indication * that progress has been made else where. It can wait for other * tasks to attempt high level approaches to freeing memory such as * compaction (which removes fragmentation) and page-out. * There is still a definite limit to the number of retries, but it is * a larger limit than with %__GFP_NORETRY. * Allocations with this flag may fail, but only when there is * genuinely little unused memory. While these allocations do not * directly trigger the OOM killer, their failure indicates that * the system is likely to need to use the OOM killer soon. The * caller must handle failure, but can reasonably do so by failing * a higher-level request, or completing it only in a much less * efficient manner. * If the allocation does fail, and the caller is in a position to * free some non-essential memory, doing so could benefit the system * as a whole. * * %__GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller * cannot handle allocation failures. The allocation could block * indefinitely but will never return with failure. Testing for * failure is pointless. * New users should be evaluated carefully (and the flag should be * used only when there is no reasonable failure policy) but it is * definitely preferable to use the flag rather than opencode endless * loop around allocator. * Using this flag for costly allocations is _highly_ discouraged. |
dd56b0464 mm: page_alloc: h... |
205 206 207 |
*/ #define __GFP_IO ((__force gfp_t)___GFP_IO) #define __GFP_FS ((__force gfp_t)___GFP_FS) |
d0164adc8 mm, page_alloc: d... |
208 209 |
#define __GFP_DIRECT_RECLAIM ((__force gfp_t)___GFP_DIRECT_RECLAIM) /* Caller can reclaim */ #define __GFP_KSWAPD_RECLAIM ((__force gfp_t)___GFP_KSWAPD_RECLAIM) /* kswapd can wake */ |
dd56b0464 mm: page_alloc: h... |
210 |
#define __GFP_RECLAIM ((__force gfp_t)(___GFP_DIRECT_RECLAIM|___GFP_KSWAPD_RECLAIM)) |
dcda9b047 mm, tree wide: re... |
211 |
#define __GFP_RETRY_MAYFAIL ((__force gfp_t)___GFP_RETRY_MAYFAIL) |
dd56b0464 mm: page_alloc: h... |
212 213 |
#define __GFP_NOFAIL ((__force gfp_t)___GFP_NOFAIL) #define __GFP_NORETRY ((__force gfp_t)___GFP_NORETRY) |
d0164adc8 mm, page_alloc: d... |
214 |
|
263fade51 docs/mm: make GFP... |
215 216 217 |
/** * DOC: Action modifiers * |
dd56b0464 mm: page_alloc: h... |
218 |
* Action modifiers |
263fade51 docs/mm: make GFP... |
219 |
* ~~~~~~~~~~~~~~~~ |
dd56b0464 mm: page_alloc: h... |
220 |
* |
263fade51 docs/mm: make GFP... |
221 |
* %__GFP_NOWARN suppresses allocation failure reports. |
dd56b0464 mm: page_alloc: h... |
222 |
* |
263fade51 docs/mm: make GFP... |
223 |
* %__GFP_COMP address compound page metadata. |
dd56b0464 mm: page_alloc: h... |
224 |
* |
263fade51 docs/mm: make GFP... |
225 |
* %__GFP_ZERO returns a zeroed page on success. |
2dff44052 kmemcheck: add mm... |
226 |
*/ |
dd56b0464 mm: page_alloc: h... |
227 228 229 |
#define __GFP_NOWARN ((__force gfp_t)___GFP_NOWARN) #define __GFP_COMP ((__force gfp_t)___GFP_COMP) #define __GFP_ZERO ((__force gfp_t)___GFP_ZERO) |
2dff44052 kmemcheck: add mm... |
230 |
|
7e7844226 lockdep: allow to... |
231 232 |
/* Disable lockdep for GFP context tracking */ #define __GFP_NOLOCKDEP ((__force gfp_t)___GFP_NOLOCKDEP) |
dd56b0464 mm: page_alloc: h... |
233 |
/* Room for N __GFP_FOO bits */ |
7ff00a49a ANDROID: cma: red... |
234 235 236 |
#ifdef CONFIG_CMA #define __GFP_BITS_SHIFT (24 + IS_ENABLED(CONFIG_LOCKDEP)) #else |
e67d4ca79 mm: save two stra... |
237 |
#define __GFP_BITS_SHIFT (23 + IS_ENABLED(CONFIG_LOCKDEP)) |
7ff00a49a ANDROID: cma: red... |
238 |
#endif |
af4ca457e [PATCH] gfp_t: in... |
239 |
#define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1)) |
1da177e4c Linux-2.6.12-rc2 |
240 |
|
263fade51 docs/mm: make GFP... |
241 242 243 244 245 246 |
/** * DOC: Useful GFP flag combinations * * Useful GFP flag combinations * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * |
dd56b0464 mm: page_alloc: h... |
247 248 |
* Useful GFP flag combinations that are commonly used. It is recommended * that subsystems start with one of these combinations and then set/clear |
263fade51 docs/mm: make GFP... |
249 250 251 |
* %__GFP_FOO flags as necessary. * * %GFP_ATOMIC users can not sleep and need the allocation to succeed. A lower |
ab00db216 include/linux/gfp... |
252 253 254 |
* watermark is applied to allow access to "atomic reserves". * The current implementation doesn't support NMI and few other strict * non-preemptive contexts (e.g. raw_spin_lock). The same applies to %GFP_NOWAIT. |
263fade51 docs/mm: make GFP... |
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 |
* * %GFP_KERNEL is typical for kernel-internal allocations. The caller requires * %ZONE_NORMAL or a lower zone for direct access but can direct reclaim. * * %GFP_KERNEL_ACCOUNT is the same as GFP_KERNEL, except the allocation is * accounted to kmemcg. * * %GFP_NOWAIT is for kernel allocations that should not stall for direct * reclaim, start physical IO or use any filesystem callback. * * %GFP_NOIO will use direct reclaim to discard clean pages or slab pages * that do not require the starting of any physical IO. * Please try to avoid using this flag directly and instead use * memalloc_noio_{save,restore} to mark the whole scope which cannot * perform any IO with a short explanation why. All allocation requests * will inherit GFP_NOIO implicitly. * * %GFP_NOFS will use direct reclaim but will not use any filesystem interfaces. * Please try to avoid using this flag directly and instead use * memalloc_nofs_{save,restore} to mark the whole scope which cannot/shouldn't * recurse into the FS layer with a short explanation why. All allocation * requests will inherit GFP_NOFS implicitly. * * %GFP_USER is for userspace allocations that also need to be directly * accessibly by the kernel or hardware. It is typically used by hardware * for buffers that are mapped to userspace (e.g. graphics) that hardware * still must DMA to. cpuset limits are enforced for these allocations. * * %GFP_DMA exists for historical reasons and should be avoided where possible. * The flags indicates that the caller requires that the lowest zone be * used (%ZONE_DMA or 16M on x86-64). Ideally, this would be removed but * it would require careful auditing as some users really require it and * others use the flag to avoid lowmem reserves in %ZONE_DMA and treat the * lowest zone as a type of emergency reserve. * * %GFP_DMA32 is similar to %GFP_DMA except that the caller requires a 32-bit * address. * * %GFP_HIGHUSER is for userspace allocations that may be mapped to userspace, * do not need to be directly accessible by the kernel but that cannot * move once in use. An example may be a hardware allocation that maps * data directly into userspace but has no addressing limitations. * * %GFP_HIGHUSER_MOVABLE is for userspace allocations that the kernel does not * need direct access to but can use kmap() when access is required. They * are expected to be movable via page reclaim or page migration. Typically, * pages on the LRU would also be allocated with %GFP_HIGHUSER_MOVABLE. * * %GFP_TRANSHUGE and %GFP_TRANSHUGE_LIGHT are used for THP allocations. They * are compound allocations that will generally fail quickly if memory is not * available and will not wake kswapd/kcompactd on failure. The _LIGHT * version does not attempt reclaim/compaction at all and is by default used * in page fault path, while the non-light is used by khugepaged. |
d0164adc8 mm, page_alloc: d... |
308 309 |
*/ #define GFP_ATOMIC (__GFP_HIGH|__GFP_ATOMIC|__GFP_KSWAPD_RECLAIM) |
dd56b0464 mm: page_alloc: h... |
310 |
#define GFP_KERNEL (__GFP_RECLAIM | __GFP_IO | __GFP_FS) |
a9bb7e620 memcg: only accou... |
311 |
#define GFP_KERNEL_ACCOUNT (GFP_KERNEL | __GFP_ACCOUNT) |
d0164adc8 mm, page_alloc: d... |
312 |
#define GFP_NOWAIT (__GFP_KSWAPD_RECLAIM) |
71baba4b9 mm, page_alloc: r... |
313 314 |
#define GFP_NOIO (__GFP_RECLAIM) #define GFP_NOFS (__GFP_RECLAIM | __GFP_IO) |
71baba4b9 mm, page_alloc: r... |
315 |
#define GFP_USER (__GFP_RECLAIM | __GFP_IO | __GFP_FS | __GFP_HARDWALL) |
dd56b0464 mm: page_alloc: h... |
316 317 |
#define GFP_DMA __GFP_DMA #define GFP_DMA32 __GFP_DMA32 |
2d48366b3 mm, gfp: escalate... |
318 319 |
#define GFP_HIGHUSER (GFP_USER | __GFP_HIGHMEM) #define GFP_HIGHUSER_MOVABLE (GFP_HIGHUSER | __GFP_MOVABLE) |
251603549 mm, thp: remove _... |
320 321 322 |
#define GFP_TRANSHUGE_LIGHT ((GFP_HIGHUSER_MOVABLE | __GFP_COMP | \ __GFP_NOMEMALLOC | __GFP_NOWARN) & ~__GFP_RECLAIM) #define GFP_TRANSHUGE (GFP_TRANSHUGE_LIGHT | __GFP_DIRECT_RECLAIM) |
1da177e4c Linux-2.6.12-rc2 |
323 |
|
dd56b0464 mm: page_alloc: h... |
324 |
/* Convert GFP flags to their corresponding migrate type */ |
e12ba74d8 Group short-lived... |
325 |
#define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE) |
016c13daa mm, page_alloc: u... |
326 |
#define GFP_MOVABLE_SHIFT 3 |
6cb062296 Categorize GFP flags |
327 |
|
01c0bfe06 mm: rename gfpfla... |
328 |
static inline int gfp_migratetype(const gfp_t gfp_flags) |
467c996c1 Print out statist... |
329 |
{ |
016c13daa mm, page_alloc: u... |
330 331 332 |
VM_WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK); BUILD_BUG_ON((1UL << GFP_MOVABLE_SHIFT) != ___GFP_MOVABLE); BUILD_BUG_ON((___GFP_MOVABLE >> GFP_MOVABLE_SHIFT) != MIGRATE_MOVABLE); |
467c996c1 Print out statist... |
333 334 335 336 337 |
if (unlikely(page_group_by_mobility_disabled)) return MIGRATE_UNMOVABLE; /* Group based on mobility */ |
016c13daa mm, page_alloc: u... |
338 |
return (gfp_flags & GFP_MOVABLE_MASK) >> GFP_MOVABLE_SHIFT; |
467c996c1 Print out statist... |
339 |
} |
dd56b0464 mm: page_alloc: h... |
340 341 |
#undef GFP_MOVABLE_MASK #undef GFP_MOVABLE_SHIFT |
a2f1b4249 [PATCH] x86_64: A... |
342 |
|
d0164adc8 mm, page_alloc: d... |
343 344 |
static inline bool gfpflags_allow_blocking(const gfp_t gfp_flags) { |
543dfb2df mm: fix noisy spa... |
345 |
return !!(gfp_flags & __GFP_DIRECT_RECLAIM); |
d0164adc8 mm, page_alloc: d... |
346 |
} |
20eb4f29b net: fix sk_page_... |
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 |
/** * gfpflags_normal_context - is gfp_flags a normal sleepable context? * @gfp_flags: gfp_flags to test * * Test whether @gfp_flags indicates that the allocation is from the * %current context and allowed to sleep. * * An allocation being allowed to block doesn't mean it owns the %current * context. When direct reclaim path tries to allocate memory, the * allocation context is nested inside whatever %current was doing at the * time of the original allocation. The nested allocation may be allowed * to block but modifying anything %current owns can corrupt the outer * context's expectations. * * %true result from this function indicates that the allocation context * can sleep and use anything that's associated with %current. */ static inline bool gfpflags_normal_context(const gfp_t gfp_flags) { return (gfp_flags & (__GFP_DIRECT_RECLAIM | __GFP_MEMALLOC)) == __GFP_DIRECT_RECLAIM; } |
b70d94ee4 page-allocator: u... |
369 370 371 372 373 |
#ifdef CONFIG_HIGHMEM #define OPT_ZONE_HIGHMEM ZONE_HIGHMEM #else #define OPT_ZONE_HIGHMEM ZONE_NORMAL #endif |
4b51d6698 [PATCH] optional ... |
374 |
#ifdef CONFIG_ZONE_DMA |
b70d94ee4 page-allocator: u... |
375 376 377 |
#define OPT_ZONE_DMA ZONE_DMA #else #define OPT_ZONE_DMA ZONE_NORMAL |
4b51d6698 [PATCH] optional ... |
378 |
#endif |
b70d94ee4 page-allocator: u... |
379 |
|
4e4785bcf [PATCH] mempolici... |
380 |
#ifdef CONFIG_ZONE_DMA32 |
b70d94ee4 page-allocator: u... |
381 382 383 |
#define OPT_ZONE_DMA32 ZONE_DMA32 #else #define OPT_ZONE_DMA32 ZONE_NORMAL |
4e4785bcf [PATCH] mempolici... |
384 |
#endif |
b70d94ee4 page-allocator: u... |
385 386 387 |
/* * GFP_ZONE_TABLE is a word size bitstring that is used for looking up the |
ac2e8e40a mm: fix spelling ... |
388 389 |
* zone to use given the lowest 4 bits of gfp_t. Entries are GFP_ZONES_SHIFT * bits long and there are 16 of them to cover all possible combinations of |
263ff5d8e include/linux/gfp... |
390 |
* __GFP_DMA, __GFP_DMA32, __GFP_MOVABLE and __GFP_HIGHMEM. |
b70d94ee4 page-allocator: u... |
391 392 393 394 |
* * The zone fallback order is MOVABLE=>HIGHMEM=>NORMAL=>DMA32=>DMA. * But GFP_MOVABLE is not only a zone specifier but also an allocation * policy. Therefore __GFP_MOVABLE plus another zone selector is valid. |
263ff5d8e include/linux/gfp... |
395 |
* Only 1 bit of the lowest 3 bits (DMA,DMA32,HIGHMEM) can be set to "1". |
b70d94ee4 page-allocator: u... |
396 397 398 399 400 401 402 |
* * bit result * ================= * 0x0 => NORMAL * 0x1 => DMA or NORMAL * 0x2 => HIGHMEM or NORMAL * 0x3 => BAD (DMA+HIGHMEM) |
4b33b6959 include/linux/gfp... |
403 |
* 0x4 => DMA32 or NORMAL |
b70d94ee4 page-allocator: u... |
404 405 406 407 408 409 410 |
* 0x5 => BAD (DMA+DMA32) * 0x6 => BAD (HIGHMEM+DMA32) * 0x7 => BAD (HIGHMEM+DMA32+DMA) * 0x8 => NORMAL (MOVABLE+0) * 0x9 => DMA or NORMAL (MOVABLE+DMA) * 0xa => MOVABLE (Movable is valid only if HIGHMEM is set too) * 0xb => BAD (MOVABLE+HIGHMEM+DMA) |
4b33b6959 include/linux/gfp... |
411 |
* 0xc => DMA32 or NORMAL (MOVABLE+DMA32) |
b70d94ee4 page-allocator: u... |
412 413 414 415 |
* 0xd => BAD (MOVABLE+DMA32+DMA) * 0xe => BAD (MOVABLE+DMA32+HIGHMEM) * 0xf => BAD (MOVABLE+DMA32+HIGHMEM+DMA) * |
b11a7b941 mm: exclude ZONE_... |
416 |
* GFP_ZONES_SHIFT must be <= 2 on 32 bit platforms. |
b70d94ee4 page-allocator: u... |
417 |
*/ |
b11a7b941 mm: exclude ZONE_... |
418 419 420 421 422 423 424 425 426 |
#if defined(CONFIG_ZONE_DEVICE) && (MAX_NR_ZONES-1) <= 4 /* ZONE_DEVICE is not a valid GFP zone specifier */ #define GFP_ZONES_SHIFT 2 #else #define GFP_ZONES_SHIFT ZONES_SHIFT #endif #if 16 * GFP_ZONES_SHIFT > BITS_PER_LONG #error GFP_ZONES_SHIFT too large to create GFP_ZONE_TABLE integer |
b70d94ee4 page-allocator: u... |
427 428 429 |
#endif #define GFP_ZONE_TABLE ( \ |
b11a7b941 mm: exclude ZONE_... |
430 431 432 433 434 435 436 437 |
(ZONE_NORMAL << 0 * GFP_ZONES_SHIFT) \ | (OPT_ZONE_DMA << ___GFP_DMA * GFP_ZONES_SHIFT) \ | (OPT_ZONE_HIGHMEM << ___GFP_HIGHMEM * GFP_ZONES_SHIFT) \ | (OPT_ZONE_DMA32 << ___GFP_DMA32 * GFP_ZONES_SHIFT) \ | (ZONE_NORMAL << ___GFP_MOVABLE * GFP_ZONES_SHIFT) \ | (OPT_ZONE_DMA << (___GFP_MOVABLE | ___GFP_DMA) * GFP_ZONES_SHIFT) \ | (ZONE_MOVABLE << (___GFP_MOVABLE | ___GFP_HIGHMEM) * GFP_ZONES_SHIFT)\ | (OPT_ZONE_DMA32 << (___GFP_MOVABLE | ___GFP_DMA32) * GFP_ZONES_SHIFT)\ |
b70d94ee4 page-allocator: u... |
438 439 440 |
) /* |
263ff5d8e include/linux/gfp... |
441 |
* GFP_ZONE_BAD is a bitmap for all combinations of __GFP_DMA, __GFP_DMA32 |
b70d94ee4 page-allocator: u... |
442 443 444 445 446 |
* __GFP_HIGHMEM and __GFP_MOVABLE that are not permitted. One flag per * entry starting with bit 0. Bit is set if the combination is not * allowed. */ #define GFP_ZONE_BAD ( \ |
16b56cf4b mm: fix sparse wa... |
447 448 449 450 451 452 453 454 |
1 << (___GFP_DMA | ___GFP_HIGHMEM) \ | 1 << (___GFP_DMA | ___GFP_DMA32) \ | 1 << (___GFP_DMA32 | ___GFP_HIGHMEM) \ | 1 << (___GFP_DMA | ___GFP_DMA32 | ___GFP_HIGHMEM) \ | 1 << (___GFP_MOVABLE | ___GFP_HIGHMEM | ___GFP_DMA) \ | 1 << (___GFP_MOVABLE | ___GFP_DMA32 | ___GFP_DMA) \ | 1 << (___GFP_MOVABLE | ___GFP_DMA32 | ___GFP_HIGHMEM) \ | 1 << (___GFP_MOVABLE | ___GFP_DMA32 | ___GFP_DMA | ___GFP_HIGHMEM) \ |
b70d94ee4 page-allocator: u... |
455 |
) |
62e32cf8f ANDROID: mm: Crea... |
456 |
enum zone_type gfp_zone(gfp_t flags); |
4e4785bcf [PATCH] mempolici... |
457 |
|
1da177e4c Linux-2.6.12-rc2 |
458 459 460 461 462 463 |
/* * There is only one page-allocator function, and two main namespaces to * it. The alloc_page*() variants return 'struct page *' and as such * can allocate highmem pages, the *get*page*() variants return * virtual kernel addresses to the allocated page(s). */ |
54a6eb5c4 mm: use two zonel... |
464 465 |
static inline int gfp_zonelist(gfp_t flags) { |
c00eb15a8 mm/zonelist: enum... |
466 467 468 469 470 |
#ifdef CONFIG_NUMA if (unlikely(flags & __GFP_THISNODE)) return ZONELIST_NOFALLBACK; #endif return ZONELIST_FALLBACK; |
54a6eb5c4 mm: use two zonel... |
471 |
} |
1da177e4c Linux-2.6.12-rc2 |
472 473 474 |
/* * We get the zone list from the current node and the gfp_mask. * This zone list contains a maximum of MAXNODES*MAX_NR_ZONES zones. |
54a6eb5c4 mm: use two zonel... |
475 476 |
* There are two zonelists per node, one for all zones with memory and * one containing just zones from the node the zonelist belongs to. |
1da177e4c Linux-2.6.12-rc2 |
477 478 479 480 |
* * For the normal case of non-DISCONTIGMEM systems the NODE_DATA() gets * optimized to &contig_page_data at compile-time. */ |
0e88460da mm: introduce nod... |
481 482 |
static inline struct zonelist *node_zonelist(int nid, gfp_t flags) { |
54a6eb5c4 mm: use two zonel... |
483 |
return NODE_DATA(nid)->node_zonelists + gfp_zonelist(flags); |
0e88460da mm: introduce nod... |
484 |
} |
1da177e4c Linux-2.6.12-rc2 |
485 486 487 488 |
#ifndef HAVE_ARCH_FREE_PAGE static inline void arch_free_page(struct page *page, int order) { } #endif |
cc1025090 [PATCH] mm: add a... |
489 490 491 |
#ifndef HAVE_ARCH_ALLOC_PAGE static inline void arch_alloc_page(struct page *page, int order) { } #endif |
f28d43636 mm/gup/writeback:... |
492 493 494 495 496 497 |
#ifndef HAVE_ARCH_MAKE_PAGE_ACCESSIBLE static inline int arch_make_page_accessible(struct page *page) { return 0; } #endif |
1da177e4c Linux-2.6.12-rc2 |
498 |
|
e4048e5dc page allocator: i... |
499 |
struct page * |
04ec6264f mm, page_alloc: p... |
500 501 |
__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order, int preferred_nid, nodemask_t *nodemask); |
e4048e5dc page allocator: i... |
502 503 |
static inline struct page * |
04ec6264f mm, page_alloc: p... |
504 |
__alloc_pages(gfp_t gfp_mask, unsigned int order, int preferred_nid) |
e4048e5dc page allocator: i... |
505 |
{ |
04ec6264f mm, page_alloc: p... |
506 |
return __alloc_pages_nodemask(gfp_mask, order, preferred_nid, NULL); |
e4048e5dc page allocator: i... |
507 |
} |
96db800f5 mm: rename alloc_... |
508 509 510 511 512 513 |
/* * Allocate pages, preferring the node given as nid. The node must be valid and * online. For more general interface, see alloc_pages_node(). */ static inline struct page * __alloc_pages_node(int nid, gfp_t gfp_mask, unsigned int order) |
1da177e4c Linux-2.6.12-rc2 |
514 |
{ |
0bc35a970 mm: unify checks ... |
515 |
VM_BUG_ON(nid < 0 || nid >= MAX_NUMNODES); |
8addc2d00 mm: do not warn o... |
516 |
VM_WARN_ON((gfp_mask & __GFP_THISNODE) && !node_online(nid)); |
819a69280 [PATCH] x86_64: H... |
517 |
|
04ec6264f mm, page_alloc: p... |
518 |
return __alloc_pages(gfp_mask, order, nid); |
1da177e4c Linux-2.6.12-rc2 |
519 |
} |
96db800f5 mm: rename alloc_... |
520 521 |
/* * Allocate pages, preferring the node given as nid. When nid == NUMA_NO_NODE, |
82c1fc714 mm: use numa_mem_... |
522 523 |
* prefer the current CPU's closest node. Otherwise node must be valid and * online. |
96db800f5 mm: rename alloc_... |
524 525 |
*/ static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask, |
6484eb3e2 page allocator: d... |
526 527 |
unsigned int order) { |
0bc35a970 mm: unify checks ... |
528 |
if (nid == NUMA_NO_NODE) |
82c1fc714 mm: use numa_mem_... |
529 |
nid = numa_mem_id(); |
6484eb3e2 page allocator: d... |
530 |
|
0bc35a970 mm: unify checks ... |
531 |
return __alloc_pages_node(nid, gfp_mask, order); |
6484eb3e2 page allocator: d... |
532 |
} |
1da177e4c Linux-2.6.12-rc2 |
533 |
#ifdef CONFIG_NUMA |
dd0fc66fb [PATCH] gfp flags... |
534 |
extern struct page *alloc_pages_current(gfp_t gfp_mask, unsigned order); |
1da177e4c Linux-2.6.12-rc2 |
535 536 |
static inline struct page * |
dd0fc66fb [PATCH] gfp flags... |
537 |
alloc_pages(gfp_t gfp_mask, unsigned int order) |
1da177e4c Linux-2.6.12-rc2 |
538 |
{ |
1da177e4c Linux-2.6.12-rc2 |
539 540 |
return alloc_pages_current(gfp_mask, order); } |
0bbbc0b33 thp: add numa awa... |
541 |
extern struct page *alloc_pages_vma(gfp_t gfp_mask, int order, |
2f5f9486f mm: change alloc_... |
542 |
struct vm_area_struct *vma, unsigned long addr, |
19deb7695 Revert "Revert "R... |
543 544 545 |
int node, bool hugepage); #define alloc_hugepage_vma(gfp_mask, vma, addr, order) \ alloc_pages_vma(gfp_mask, order, vma, addr, numa_node_id(), true) |
1da177e4c Linux-2.6.12-rc2 |
546 |
#else |
43ee5b6da mm: turn alloc_pa... |
547 548 549 550 |
static inline struct page *alloc_pages(gfp_t gfp_mask, unsigned int order) { return alloc_pages_node(numa_node_id(), gfp_mask, order); } |
19deb7695 Revert "Revert "R... |
551 552 553 |
#define alloc_pages_vma(gfp_mask, order, vma, addr, node, false)\ alloc_pages(gfp_mask, order) #define alloc_hugepage_vma(gfp_mask, vma, addr, order) \ |
077fcf116 mm/thp: allocate ... |
554 |
alloc_pages(gfp_mask, order) |
1da177e4c Linux-2.6.12-rc2 |
555 556 |
#endif #define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0) |
2f5f9486f mm: change alloc_... |
557 |
#define alloc_page_vma(gfp_mask, vma, addr) \ |
19deb7695 Revert "Revert "R... |
558 |
alloc_pages_vma(gfp_mask, 0, vma, addr, numa_node_id(), false) |
1da177e4c Linux-2.6.12-rc2 |
559 |
|
b3c975286 include/linux: Re... |
560 561 |
extern unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order); extern unsigned long get_zeroed_page(gfp_t gfp_mask); |
1da177e4c Linux-2.6.12-rc2 |
562 |
|
2be0ffe2b mm: add alloc_pag... |
563 564 |
void *alloc_pages_exact(size_t size, gfp_t gfp_mask); void free_pages_exact(void *virt, size_t size); |
e19318116 mm/page_alloc.c: ... |
565 |
void * __meminit alloc_pages_exact_nid(int nid, size_t size, gfp_t gfp_mask); |
2be0ffe2b mm: add alloc_pag... |
566 |
|
1da177e4c Linux-2.6.12-rc2 |
567 |
#define __get_free_page(gfp_mask) \ |
fd23855e3 include/linux/gfp... |
568 |
__get_free_pages((gfp_mask), 0) |
1da177e4c Linux-2.6.12-rc2 |
569 570 |
#define __get_dma_pages(gfp_mask, order) \ |
fd23855e3 include/linux/gfp... |
571 |
__get_free_pages((gfp_mask) | GFP_DMA, (order)) |
1da177e4c Linux-2.6.12-rc2 |
572 |
|
b3c975286 include/linux: Re... |
573 574 |
extern void __free_pages(struct page *page, unsigned int order); extern void free_pages(unsigned long addr, unsigned int order); |
2d4894b5d mm: remove cold p... |
575 576 |
extern void free_unref_page(struct page *page); extern void free_unref_page_list(struct list_head *list); |
1da177e4c Linux-2.6.12-rc2 |
577 |
|
b63ae8ca0 mm/net: Rename an... |
578 |
struct page_frag_cache; |
2976db801 mm: rename __page... |
579 |
extern void __page_frag_cache_drain(struct page *page, unsigned int count); |
8c2dd3e4a mm: rename __allo... |
580 581 582 |
extern void *page_frag_alloc(struct page_frag_cache *nc, unsigned int fragsz, gfp_t gfp_mask); extern void page_frag_free(void *addr); |
b63ae8ca0 mm/net: Rename an... |
583 |
|
1da177e4c Linux-2.6.12-rc2 |
584 |
#define __free_page(page) __free_pages((page), 0) |
fd23855e3 include/linux/gfp... |
585 |
#define free_page(addr) free_pages((addr), 0) |
1da177e4c Linux-2.6.12-rc2 |
586 587 |
void page_alloc_init(void); |
4037d4522 Move remote node ... |
588 |
void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp); |
93481ff0e mm: introduce sin... |
589 590 |
void drain_all_pages(struct zone *zone); void drain_local_pages(struct zone *zone); |
1da177e4c Linux-2.6.12-rc2 |
591 |
|
0e1cc95b4 mm: meminit: fini... |
592 |
void page_alloc_init_late(void); |
0e1cc95b4 mm: meminit: fini... |
593 |
|
f90ac3982 mm: avoid liveloc... |
594 595 596 597 598 599 600 |
/* * gfp_allowed_mask is set to GFP_BOOT_MASK during early boot to restrict what * GFP flags are used before interrupts are enabled. Once interrupts are * enabled, it is set to __GFP_BITS_MASK while the system is running. During * hibernation, it is used by PM to avoid I/O during memory allocation while * devices are suspended. */ |
dcce284a2 mm: Extend gfp ma... |
601 |
extern gfp_t gfp_allowed_mask; |
c93bdd0e0 netvm: allow skb ... |
602 603 |
/* Returns true if the gfp_mask allows use of ALLOC_NO_WATERMARK */ bool gfp_pfmemalloc_allowed(gfp_t gfp_mask); |
c9e664f1f PM / Hibernate: F... |
604 605 |
extern void pm_restrict_gfp_mask(void); extern void pm_restore_gfp_mask(void); |
dcce284a2 mm: Extend gfp ma... |
606 |
|
f90ac3982 mm: avoid liveloc... |
607 608 609 610 611 612 613 614 |
#ifdef CONFIG_PM_SLEEP extern bool pm_suspended_storage(void); #else static inline bool pm_suspended_storage(void) { return false; } #endif /* CONFIG_PM_SLEEP */ |
8df995f6b mm: simplify MEMO... |
615 |
#ifdef CONFIG_CONTIG_ALLOC |
041d3a8cd mm: page_alloc: i... |
616 |
/* The below functions must be run on a range from a single zone. */ |
0815f3d81 mm: page_isolatio... |
617 |
extern int alloc_contig_range(unsigned long start, unsigned long end, |
ca96b6253 mm: alloc_contig_... |
618 |
unsigned migratetype, gfp_t gfp_mask); |
5e27a2df0 mm/page_alloc: ad... |
619 620 |
extern struct page *alloc_contig_pages(unsigned long nr_pages, gfp_t gfp_mask, int nid, nodemask_t *nodemask); |
080fe2068 mm, hugetlb: don'... |
621 |
#endif |
4eb0716e8 hugetlb: allow to... |
622 |
void free_contig_range(unsigned long pfn, unsigned int nr_pages); |
041d3a8cd mm: page_alloc: i... |
623 |
|
080fe2068 mm, hugetlb: don'... |
624 |
#ifdef CONFIG_CMA |
47118af07 mm: mmzone: MIGRA... |
625 626 |
/* CMA stuff */ extern void init_cma_reserved_pageblock(struct page *page); |
041d3a8cd mm: page_alloc: i... |
627 |
#endif |
1da177e4c Linux-2.6.12-rc2 |
628 |
#endif /* __LINUX_GFP_H */ |