Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.
1: #ifndef __LINUX_GFP_H 2: #define __LINUX_GFP_H 3: 4: #include <linux/mmzone.h> 5: #include <linux/stddef.h> 6: #include <linux/linkage.h> 7: #include <linux/topology.h> 8: #include <linux/mmdebug.h> 9: 10: struct vm_area_struct; 11: 12: /* Plain integer GFP bitmasks. Do not use this directly. */ 13: #define ___GFP_DMA 0x01u 14: #define ___GFP_HIGHMEM 0x02u 15: #define ___GFP_DMA32 0x04u 16: #define ___GFP_MOVABLE 0x08u 17: #define ___GFP_WAIT 0x10u 18: #define ___GFP_HIGH 0x20u 19: #define ___GFP_IO 0x40u 20: #define ___GFP_FS 0x80u 21: #define ___GFP_COLD 0x100u 22: #define ___GFP_NOWARN 0x200u 23: #define ___GFP_REPEAT 0x400u 24: #define ___GFP_NOFAIL 0x800u 25: #define ___GFP_NORETRY 0x1000u 26: #define ___GFP_MEMALLOC 0x2000u 27: #define ___GFP_COMP 0x4000u 28: #define ___GFP_ZERO 0x8000u 29: #define ___GFP_NOMEMALLOC 0x10000u 30: #define ___GFP_HARDWALL 0x20000u 31: #define ___GFP_THISNODE 0x40000u 32: #define ___GFP_RECLAIMABLE 0x80000u 33: #define ___GFP_KMEMCG 0x100000u 34: #define ___GFP_NOTRACK 0x200000u 35: #define ___GFP_NO_KSWAPD 0x400000u 36: #define ___GFP_OTHER_NODE 0x800000u 37: #define ___GFP_WRITE 0x1000000u 38: /* If the above are modified, __GFP_BITS_SHIFT may need updating */ 39: 40: /* 41: * GFP bitmasks.. 42: * 43: * Zone modifiers (see linux/mmzone.h - low three bits) 44: * 45: * Do not put any conditional on these. If necessary modify the definitions 46: * without the underscores and use them consistently. The definitions here may 47: * be used in bit comparisons. 48: */ 49: #define __GFP_DMA ((__force gfp_t)___GFP_DMA) 50: #define __GFP_HIGHMEM ((__force gfp_t)___GFP_HIGHMEM) 51: #define __GFP_DMA32 ((__force gfp_t)___GFP_DMA32) 52: #define __GFP_MOVABLE ((__force gfp_t)___GFP_MOVABLE) /* Page is movable */ 53: #define GFP_ZONEMASK (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE) 54: /* 55: * Action modifiers - doesn't change the zoning 56: * 57: * __GFP_REPEAT: Try hard to allocate the memory, but the allocation attempt 58: * _might_ fail. This depends upon the particular VM implementation. 59: * 60: * __GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller 61: * cannot handle allocation failures. This modifier is deprecated and no new 62: * users should be added. 63: * 64: * __GFP_NORETRY: The VM implementation must not retry indefinitely. 65: * 66: * __GFP_MOVABLE: Flag that this page will be movable by the page migration 67: * mechanism or reclaimed 68: */ 69: #define __GFP_WAIT ((__force gfp_t)___GFP_WAIT) /* Can wait and reschedule? */ 70: #define __GFP_HIGH ((__force gfp_t)___GFP_HIGH) /* Should access emergency pools? */ 71: #define __GFP_IO ((__force gfp_t)___GFP_IO) /* Can start physical IO? */ 72: #define __GFP_FS ((__force gfp_t)___GFP_FS) /* Can call down to low-level FS? */ 73: #define __GFP_COLD ((__force gfp_t)___GFP_COLD) /* Cache-cold page required */ 74: #define __GFP_NOWARN ((__force gfp_t)___GFP_NOWARN) /* Suppress page allocation failure warning */ 75: #define __GFP_REPEAT ((__force gfp_t)___GFP_REPEAT) /* See above */ 76: #define __GFP_NOFAIL ((__force gfp_t)___GFP_NOFAIL) /* See above */ 77: #define __GFP_NORETRY ((__force gfp_t)___GFP_NORETRY) /* See above */ 78: #define __GFP_MEMALLOC ((__force gfp_t)___GFP_MEMALLOC)/* Allow access to emergency reserves */ 79: #define __GFP_COMP ((__force gfp_t)___GFP_COMP) /* Add compound page metadata */ 80: #define __GFP_ZERO ((__force gfp_t)___GFP_ZERO) /* Return zeroed page on success */ 81: #define __GFP_NOMEMALLOC ((__force gfp_t)___GFP_NOMEMALLOC) /* Don't use emergency reserves. 82: * This takes precedence over the 83: * __GFP_MEMALLOC flag if both are 84: * set 85: */ 86: #define __GFP_HARDWALL ((__force gfp_t)___GFP_HARDWALL) /* Enforce hardwall cpuset memory allocs */ 87: #define __GFP_THISNODE ((__force gfp_t)___GFP_THISNODE)/* No fallback, no policies */ 88: #define __GFP_RECLAIMABLE ((__force gfp_t)___GFP_RECLAIMABLE) /* Page is reclaimable */ 89: #define __GFP_NOTRACK ((__force gfp_t)___GFP_NOTRACK) /* Don't track with kmemcheck */ 90: 91: #define __GFP_NO_KSWAPD ((__force gfp_t)___GFP_NO_KSWAPD) 92: #define __GFP_OTHER_NODE ((__force gfp_t)___GFP_OTHER_NODE) /* On behalf of other node */ 93: #define __GFP_KMEMCG ((__force gfp_t)___GFP_KMEMCG) /* Allocation comes from a memcg-accounted resource */ 94: #define __GFP_WRITE ((__force gfp_t)___GFP_WRITE) /* Allocator intends to dirty page */ 95: 96: /* 97: * This may seem redundant, but it's a way of annotating false positives vs. 98: * allocations that simply cannot be supported (e.g. page tables). 99: */ 100: #define __GFP_NOTRACK_FALSE_POSITIVE (__GFP_NOTRACK) 101: 102: #define __GFP_BITS_SHIFT 25 /* Room for N __GFP_FOO bits */ 103: #define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1)) 104: 105: /* This equals 0, but use constants in case they ever change */ 106: #define GFP_NOWAIT (GFP_ATOMIC & ~__GFP_HIGH) 107: /* GFP_ATOMIC means both !wait (__GFP_WAIT not set) and use emergency pool */ 108: #define GFP_ATOMIC (__GFP_HIGH) 109: #define GFP_NOIO (__GFP_WAIT) 110: #define GFP_NOFS (__GFP_WAIT | __GFP_IO) 111: #define GFP_KERNEL (__GFP_WAIT | __GFP_IO | __GFP_FS) 112: #define GFP_TEMPORARY (__GFP_WAIT | __GFP_IO | __GFP_FS | \ 113: __GFP_RECLAIMABLE) 114: #define GFP_USER (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL) 115: #define GFP_HIGHUSER (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL | \ 116: __GFP_HIGHMEM) 117: #define GFP_HIGHUSER_MOVABLE (__GFP_WAIT | __GFP_IO | __GFP_FS | \ 118: __GFP_HARDWALL | __GFP_HIGHMEM | \ 119: __GFP_MOVABLE) 120: #define GFP_IOFS (__GFP_IO | __GFP_FS) 121: #define GFP_TRANSHUGE (GFP_HIGHUSER_MOVABLE | __GFP_COMP | \ 122: __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN | \ 123: __GFP_NO_KSWAPD) 124: 125: #ifdef CONFIG_NUMA 126: #define GFP_THISNODE (__GFP_THISNODE | __GFP_NOWARN | __GFP_NORETRY) 127: #else 128: #define GFP_THISNODE ((__force gfp_t)0) 129: #endif 130: 131: /* This mask makes up all the page movable related flags */ 132: #define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE) 133: 134: /* Control page allocator reclaim behavior */ 135: #define GFP_RECLAIM_MASK (__GFP_WAIT|__GFP_HIGH|__GFP_IO|__GFP_FS|\ __GFP_NOWARN|__GFP_REPEAT|__GFP_NOFAIL|\ __GFP_NORETRY|__GFP_MEMALLOC|__GFP_NOMEMALLOC) 138: 139: /* Control slab gfp mask during early boot */ 140: #define GFP_BOOT_MASK (__GFP_BITS_MASK & ~(__GFP_WAIT|__GFP_IO|__GFP_FS)) 141: 142: /* Control allocation constraints */ 143: #define GFP_CONSTRAINT_MASK (__GFP_HARDWALL|__GFP_THISNODE) 144: 145: /* Do not use these with a slab allocator */ 146: #define GFP_SLAB_BUG_MASK (__GFP_DMA32|__GFP_HIGHMEM|~__GFP_BITS_MASK) 147: 148: /* Flag - indicates that the buffer will be suitable for DMA. Ignored on some 149: platforms, used as appropriate on others */ 150: 151: #define GFP_DMA __GFP_DMA 152: 153: /* 4GB DMA on some platforms */ 154: #define GFP_DMA32 __GFP_DMA32 155: 156: /* Convert GFP flags to their corresponding migrate type */ 157: static inline int allocflags_to_migratetype(gfp_t gfp_flags) 158: { 159: WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK); 160: 161: if (unlikely(page_group_by_mobility_disabled)) 162: return MIGRATE_UNMOVABLE; 163: 164: /* Group based on mobility */ 165: return (((gfp_flags & __GFP_MOVABLE) != 0) << 1) | 166: ((gfp_flags & __GFP_RECLAIMABLE) != 0); 167: } 168: 169: #ifdef CONFIG_HIGHMEM 170: #define OPT_ZONE_HIGHMEM ZONE_HIGHMEM 171: #else 172: #define OPT_ZONE_HIGHMEM ZONE_NORMAL 173: #endif 174: 175: #ifdef CONFIG_ZONE_DMA 176: #define OPT_ZONE_DMA ZONE_DMA 177: #else 178: #define OPT_ZONE_DMA ZONE_NORMAL 179: #endif 180: 181: #ifdef CONFIG_ZONE_DMA32 182: #define OPT_ZONE_DMA32 ZONE_DMA32 183: #else 184: #define OPT_ZONE_DMA32 ZONE_NORMAL 185: #endif 186: 187: /* 188: * GFP_ZONE_TABLE is a word size bitstring that is used for looking up the 189: * zone to use given the lowest 4 bits of gfp_t. Entries are ZONE_SHIFT long 190: * and there are 16 of them to cover all possible combinations of 191: * __GFP_DMA, __GFP_DMA32, __GFP_MOVABLE and __GFP_HIGHMEM. 192: * 193: * The zone fallback order is MOVABLE=>HIGHMEM=>NORMAL=>DMA32=>DMA. 194: * But GFP_MOVABLE is not only a zone specifier but also an allocation 195: * policy. Therefore __GFP_MOVABLE plus another zone selector is valid. 196: * Only 1 bit of the lowest 3 bits (DMA,DMA32,HIGHMEM) can be set to "1". 197: * 198: * bit result 199: * ================= 200: * 0x0 => NORMAL 201: * 0x1 => DMA or NORMAL 202: * 0x2 => HIGHMEM or NORMAL 203: * 0x3 => BAD (DMA+HIGHMEM) 204: * 0x4 => DMA32 or DMA or NORMAL 205: * 0x5 => BAD (DMA+DMA32) 206: * 0x6 => BAD (HIGHMEM+DMA32) 207: * 0x7 => BAD (HIGHMEM+DMA32+DMA) 208: * 0x8 => NORMAL (MOVABLE+0) 209: * 0x9 => DMA or NORMAL (MOVABLE+DMA) 210: * 0xa => MOVABLE (Movable is valid only if HIGHMEM is set too) 211: * 0xb => BAD (MOVABLE+HIGHMEM+DMA) 212: * 0xc => DMA32 (MOVABLE+DMA32) 213: * 0xd => BAD (MOVABLE+DMA32+DMA) 214: * 0xe => BAD (MOVABLE+DMA32+HIGHMEM) 215: * 0xf => BAD (MOVABLE+DMA32+HIGHMEM+DMA) 216: * 217: * ZONES_SHIFT must be <= 2 on 32 bit platforms. 218: */ 219: 220: #if 16 * ZONES_SHIFT > BITS_PER_LONG 221: #error ZONES_SHIFT too large to create GFP_ZONE_TABLE integer 222: #endif 223: 224: #define GFP_ZONE_TABLE ( \ 225: (ZONE_NORMAL << 0 * ZONES_SHIFT) \ 226: | (OPT_ZONE_DMA << ___GFP_DMA * ZONES_SHIFT) \ 227: | (OPT_ZONE_HIGHMEM << ___GFP_HIGHMEM * ZONES_SHIFT) \ 228: | (OPT_ZONE_DMA32 << ___GFP_DMA32 * ZONES_SHIFT) \ 229: | (ZONE_NORMAL << ___GFP_MOVABLE * ZONES_SHIFT) \ 230: | (OPT_ZONE_DMA << (___GFP_MOVABLE | ___GFP_DMA) * ZONES_SHIFT) \ 231: | (ZONE_MOVABLE << (___GFP_MOVABLE | ___GFP_HIGHMEM) * ZONES_SHIFT) \ 232: | (OPT_ZONE_DMA32 << (___GFP_MOVABLE | ___GFP_DMA32) * ZONES_SHIFT) \ 233: ) 234: 235: /* 236: * GFP_ZONE_BAD is a bitmap for all combinations of __GFP_DMA, __GFP_DMA32 237: * __GFP_HIGHMEM and __GFP_MOVABLE that are not permitted. One flag per 238: * entry starting with bit 0. Bit is set if the combination is not 239: * allowed. 240: */ 241: #define GFP_ZONE_BAD ( \ 242: 1 << (___GFP_DMA | ___GFP_HIGHMEM) \ 243: | 1 << (___GFP_DMA | ___GFP_DMA32) \ 244: | 1 << (___GFP_DMA32 | ___GFP_HIGHMEM) \ 245: | 1 << (___GFP_DMA | ___GFP_DMA32 | ___GFP_HIGHMEM) \ 246: | 1 << (___GFP_MOVABLE | ___GFP_HIGHMEM | ___GFP_DMA) \ 247: | 1 << (___GFP_MOVABLE | ___GFP_DMA32 | ___GFP_DMA) \ 248: | 1 << (___GFP_MOVABLE | ___GFP_DMA32 | ___GFP_HIGHMEM) \ 249: | 1 << (___GFP_MOVABLE | ___GFP_DMA32 | ___GFP_DMA | ___GFP_HIGHMEM) \ 250: ) 251: 252: static inline enum zone_type gfp_zone(gfp_t flags) 253: { 254: enum zone_type z; 255: int bit = (__force int) (flags & GFP_ZONEMASK); 256: 257: z = (GFP_ZONE_TABLE >> (bit * ZONES_SHIFT)) & 258: ((1 << ZONES_SHIFT) - 1); 259: VM_BUG_ON((GFP_ZONE_BAD >> bit) & 1); 260: return z; 261: } 262: 263: /* 264: * There is only one page-allocator function, and two main namespaces to 265: * it. The alloc_page*() variants return 'struct page *' and as such 266: * can allocate highmem pages, the *get*page*() variants return 267: * virtual kernel addresses to the allocated page(s). 268: */ 269: 270: static inline int gfp_zonelist(gfp_t flags) 271: { 272: if (IS_ENABLED(CONFIG_NUMA) && unlikely(flags & __GFP_THISNODE)) 273: return 1; 274: 275: return 0; 276: } 277: 278: /* 279: * We get the zone list from the current node and the gfp_mask. 280: * This zone list contains a maximum of MAXNODES*MAX_NR_ZONES zones. 281: * There are two zonelists per node, one for all zones with memory and 282: * one containing just zones from the node the zonelist belongs to. 283: * 284: * For the normal case of non-DISCONTIGMEM systems the NODE_DATA() gets 285: * optimized to &contig_page_data at compile-time. 286: */ 287: static inline struct zonelist *node_zonelist(int nid, gfp_t flags) 288: { 289: return NODE_DATA(nid)->node_zonelists + gfp_zonelist(flags); 290: } 291: 292: #ifndef HAVE_ARCH_FREE_PAGE 293: static inline void arch_free_page(struct page *page, int order) { } 294: #endif 295: #ifndef HAVE_ARCH_ALLOC_PAGE 296: static inline void arch_alloc_page(struct page *page, int order) { } 297: #endif 298: 299: struct page * 300: __alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order, 301: struct zonelist *zonelist, nodemask_t *nodemask); 302: 303: static inline struct page * 304: __alloc_pages(gfp_t gfp_mask, unsigned int order, 305: struct zonelist *zonelist) 306: { 307: return __alloc_pages_nodemask(gfp_mask, order, zonelist, NULL); 308: } 309: 310: static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask, 311: unsigned int order) 312: { 313: /* Unknown node is current node */ 314: if (nid < 0) 315: nid = numa_node_id(); 316: 317: return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask)); 318: } 319: 320: static inline struct page *alloc_pages_exact_node(int nid, gfp_t gfp_mask, 321: unsigned int order) 322: { 323: VM_BUG_ON(nid < 0 || nid >= MAX_NUMNODES || !node_online(nid)); 324: 325: return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask)); 326: } 327: 328: #ifdef CONFIG_NUMA 329: extern struct page *alloc_pages_current(gfp_t gfp_mask, unsigned order); 330: 331: static inline struct page * 332: alloc_pages(gfp_t gfp_mask, unsigned int order) 333: { 334: return alloc_pages_current(gfp_mask, order); 335: } 336: extern struct page *alloc_pages_vma(gfp_t gfp_mask, int order, 337: struct vm_area_struct *vma, unsigned long addr, 338: int node); 339: #else 340: #define alloc_pages(gfp_mask, order) \ 341: alloc_pages_node(numa_node_id(), gfp_mask, order) 342: #define alloc_pages_vma(gfp_mask, order, vma, addr, node) \ 343: alloc_pages(gfp_mask, order) 344: #endif 345: #define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0) 346: #define alloc_page_vma(gfp_mask, vma, addr) \ 347: alloc_pages_vma(gfp_mask, 0, vma, addr, numa_node_id()) 348: #define alloc_page_vma_node(gfp_mask, vma, addr, node) \ 349: alloc_pages_vma(gfp_mask, 0, vma, addr, node) 350: 351: extern unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order); 352: extern unsigned long get_zeroed_page(gfp_t gfp_mask); 353: 354: void *alloc_pages_exact(size_t size, gfp_t gfp_mask); 355: void free_pages_exact(void *virt, size_t size); 356: /* This is different from alloc_pages_exact_node !!! */ 357: void *alloc_pages_exact_nid(int nid, size_t size, gfp_t gfp_mask); 358: 359: #define __get_free_page(gfp_mask) \ 360: __get_free_pages((gfp_mask), 0) 361: 362: #define __get_dma_pages(gfp_mask, order) \ 363: __get_free_pages((gfp_mask) | GFP_DMA, (order)) 364: 365: extern void __free_pages(struct page *page, unsigned int order); 366: extern void free_pages(unsigned long addr, unsigned int order); 367: extern void free_hot_cold_page(struct page *page, int cold); 368: extern void free_hot_cold_page_list(struct list_head *list, int cold); 369: 370: extern void __free_memcg_kmem_pages(struct page *page, unsigned int order); 371: extern void free_memcg_kmem_pages(unsigned long addr, unsigned int order); 372: 373: #define __free_page(page) __free_pages((page), 0) 374: #define free_page(addr) free_pages((addr), 0) 375: 376: void page_alloc_init(void); 377: void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp); 378: void drain_all_pages(void); 379: void drain_local_pages(void *dummy); 380: 381: /* 382: * gfp_allowed_mask is set to GFP_BOOT_MASK during early boot to restrict what 383: * GFP flags are used before interrupts are enabled. Once interrupts are 384: * enabled, it is set to __GFP_BITS_MASK while the system is running. During 385: * hibernation, it is used by PM to avoid I/O during memory allocation while 386: * devices are suspended. 387: */ 388: extern gfp_t gfp_allowed_mask; 389: 390: /* Returns true if the gfp_mask allows use of ALLOC_NO_WATERMARK */ 391: bool gfp_pfmemalloc_allowed(gfp_t gfp_mask); 392: 393: extern void pm_restrict_gfp_mask(void); 394: extern void pm_restore_gfp_mask(void); 395: 396: #ifdef CONFIG_PM_SLEEP 397: extern bool pm_suspended_storage(void); 398: #else 399: static inline bool pm_suspended_storage(void) 400: { 401: return false; 402: } 403: #endif /* CONFIG_PM_SLEEP */ 404: 405: #ifdef CONFIG_CMA 406: 407: /* The below functions must be run on a range from a single zone. */ 408: extern int alloc_contig_range(unsigned long start, unsigned long end, 409: unsigned migratetype); 410: extern void free_contig_range(unsigned long pfn, unsigned nr_pages); 411: 412: /* CMA stuff */ 413: extern void init_cma_reserved_pageblock(struct page *page); 414: 415: #endif 416: 417: #endif /* __LINUX_GFP_H */ 418: