2005-04-16 18:20:36 -04:00
|
|
|
#ifndef __LINUX_GFP_H
|
|
|
|
#define __LINUX_GFP_H
|
|
|
|
|
|
|
|
#include <linux/mmzone.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/linkage.h>
|
2009-03-13 09:13:37 -04:00
|
|
|
#include <linux/topology.h>
|
2009-06-16 18:31:54 -04:00
|
|
|
#include <linux/mmdebug.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
struct vm_area_struct;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* GFP bitmasks..
|
2006-09-26 02:31:14 -04:00
|
|
|
*
|
|
|
|
* Zone modifiers (see linux/mmzone.h - low three bits)
|
|
|
|
*
|
|
|
|
* Do not put any conditional on these. If necessary modify the definitions
|
|
|
|
* without the underscores and use the consistently. The definitions here may
|
|
|
|
* be used in bit comparisons.
|
2005-04-16 18:20:36 -04:00
|
|
|
*/
|
2005-10-21 02:55:38 -04:00
|
|
|
#define __GFP_DMA ((__force gfp_t)0x01u)
|
|
|
|
#define __GFP_HIGHMEM ((__force gfp_t)0x02u)
|
2006-09-26 02:31:14 -04:00
|
|
|
#define __GFP_DMA32 ((__force gfp_t)0x04u)
|
2009-06-16 18:32:46 -04:00
|
|
|
#define __GFP_MOVABLE ((__force gfp_t)0x08u) /* Page is movable */
|
|
|
|
#define GFP_ZONEMASK (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* Action modifiers - doesn't change the zoning
|
|
|
|
*
|
|
|
|
* __GFP_REPEAT: Try hard to allocate the memory, but the allocation attempt
|
|
|
|
* _might_ fail. This depends upon the particular VM implementation.
|
|
|
|
*
|
|
|
|
* __GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller
|
2010-03-05 16:42:23 -05:00
|
|
|
* cannot handle allocation failures. This modifier is deprecated and no new
|
|
|
|
* users should be added.
|
2005-04-16 18:20:36 -04:00
|
|
|
*
|
|
|
|
* __GFP_NORETRY: The VM implementation must not retry indefinitely.
|
2007-07-17 07:03:05 -04:00
|
|
|
*
|
|
|
|
* __GFP_MOVABLE: Flag that this page will be movable by the page migration
|
|
|
|
* mechanism or reclaimed
|
2005-04-16 18:20:36 -04:00
|
|
|
*/
|
2005-10-21 02:55:38 -04:00
|
|
|
#define __GFP_WAIT ((__force gfp_t)0x10u) /* Can wait and reschedule? */
|
|
|
|
#define __GFP_HIGH ((__force gfp_t)0x20u) /* Should access emergency pools? */
|
|
|
|
#define __GFP_IO ((__force gfp_t)0x40u) /* Can start physical IO? */
|
|
|
|
#define __GFP_FS ((__force gfp_t)0x80u) /* Can call down to low-level FS? */
|
|
|
|
#define __GFP_COLD ((__force gfp_t)0x100u) /* Cache-cold page required */
|
|
|
|
#define __GFP_NOWARN ((__force gfp_t)0x200u) /* Suppress page allocation failure warning */
|
2008-04-29 03:58:23 -04:00
|
|
|
#define __GFP_REPEAT ((__force gfp_t)0x400u) /* See above */
|
|
|
|
#define __GFP_NOFAIL ((__force gfp_t)0x800u) /* See above */
|
|
|
|
#define __GFP_NORETRY ((__force gfp_t)0x1000u)/* See above */
|
2005-10-21 02:55:38 -04:00
|
|
|
#define __GFP_COMP ((__force gfp_t)0x4000u)/* Add compound page metadata */
|
|
|
|
#define __GFP_ZERO ((__force gfp_t)0x8000u)/* Return zeroed page on success */
|
|
|
|
#define __GFP_NOMEMALLOC ((__force gfp_t)0x10000u) /* Don't use emergency reserves */
|
2005-11-13 19:06:44 -05:00
|
|
|
#define __GFP_HARDWALL ((__force gfp_t)0x20000u) /* Enforce hardwall cpuset memory allocs */
|
2006-09-26 02:31:40 -04:00
|
|
|
#define __GFP_THISNODE ((__force gfp_t)0x40000u)/* No fallback, no policies */
|
2007-10-16 04:25:52 -04:00
|
|
|
#define __GFP_RECLAIMABLE ((__force gfp_t)0x80000u) /* Page is reclaimable */
|
2008-11-25 10:55:53 -05:00
|
|
|
|
|
|
|
#ifdef CONFIG_KMEMCHECK
|
kmemcheck: add mm functions
With kmemcheck enabled, the slab allocator needs to do this:
1. Tell kmemcheck to allocate the shadow memory which stores the status of
each byte in the allocation proper, e.g. whether it is initialized or
uninitialized.
2. Tell kmemcheck which parts of memory that should be marked uninitialized.
There are actually a few more states, such as "not yet allocated" and
"recently freed".
If a slab cache is set up using the SLAB_NOTRACK flag, it will never return
memory that can take page faults because of kmemcheck.
If a slab cache is NOT set up using the SLAB_NOTRACK flag, callers can still
request memory with the __GFP_NOTRACK flag. This does not prevent the page
faults from occuring, however, but marks the object in question as being
initialized so that no warnings will ever be produced for this object.
In addition to (and in contrast to) __GFP_NOTRACK, the
__GFP_NOTRACK_FALSE_POSITIVE flag indicates that the allocation should
not be tracked _because_ it would produce a false positive. Their values
are identical, but need not be so in the future (for example, we could now
enable/disable false positives with a config option).
Parts of this patch were contributed by Pekka Enberg but merged for
atomicity.
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
Signed-off-by: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
[rebased for mainline inclusion]
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
2008-05-31 09:56:17 -04:00
|
|
|
#define __GFP_NOTRACK ((__force gfp_t)0x200000u) /* Don't track with kmemcheck */
|
2008-11-25 10:55:53 -05:00
|
|
|
#else
|
|
|
|
#define __GFP_NOTRACK ((__force gfp_t)0)
|
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
|
kmemcheck: add mm functions
With kmemcheck enabled, the slab allocator needs to do this:
1. Tell kmemcheck to allocate the shadow memory which stores the status of
each byte in the allocation proper, e.g. whether it is initialized or
uninitialized.
2. Tell kmemcheck which parts of memory that should be marked uninitialized.
There are actually a few more states, such as "not yet allocated" and
"recently freed".
If a slab cache is set up using the SLAB_NOTRACK flag, it will never return
memory that can take page faults because of kmemcheck.
If a slab cache is NOT set up using the SLAB_NOTRACK flag, callers can still
request memory with the __GFP_NOTRACK flag. This does not prevent the page
faults from occuring, however, but marks the object in question as being
initialized so that no warnings will ever be produced for this object.
In addition to (and in contrast to) __GFP_NOTRACK, the
__GFP_NOTRACK_FALSE_POSITIVE flag indicates that the allocation should
not be tracked _because_ it would produce a false positive. Their values
are identical, but need not be so in the future (for example, we could now
enable/disable false positives with a config option).
Parts of this patch were contributed by Pekka Enberg but merged for
atomicity.
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
Signed-off-by: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
[rebased for mainline inclusion]
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
2008-05-31 09:56:17 -04:00
|
|
|
/*
|
|
|
|
* This may seem redundant, but it's a way of annotating false positives vs.
|
|
|
|
* allocations that simply cannot be supported (e.g. page tables).
|
|
|
|
*/
|
|
|
|
#define __GFP_NOTRACK_FALSE_POSITIVE (__GFP_NOTRACK)
|
|
|
|
|
|
|
|
#define __GFP_BITS_SHIFT 22 /* Room for 22 __GFP_FOO bits */
|
2005-10-21 02:55:38 -04:00
|
|
|
#define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-04-11 01:53:27 -04:00
|
|
|
/* This equals 0, but use constants in case they ever change */
|
|
|
|
#define GFP_NOWAIT (GFP_ATOMIC & ~__GFP_HIGH)
|
2006-01-11 15:17:19 -05:00
|
|
|
/* GFP_ATOMIC means both !wait (__GFP_WAIT not set) and use emergency pool */
|
2005-04-16 18:20:36 -04:00
|
|
|
#define GFP_ATOMIC (__GFP_HIGH)
|
|
|
|
#define GFP_NOIO (__GFP_WAIT)
|
|
|
|
#define GFP_NOFS (__GFP_WAIT | __GFP_IO)
|
|
|
|
#define GFP_KERNEL (__GFP_WAIT | __GFP_IO | __GFP_FS)
|
2007-10-16 04:25:52 -04:00
|
|
|
#define GFP_TEMPORARY (__GFP_WAIT | __GFP_IO | __GFP_FS | \
|
|
|
|
__GFP_RECLAIMABLE)
|
2005-09-06 18:18:10 -04:00
|
|
|
#define GFP_USER (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL)
|
|
|
|
#define GFP_HIGHUSER (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL | \
|
|
|
|
__GFP_HIGHMEM)
|
2007-07-17 07:03:05 -04:00
|
|
|
#define GFP_HIGHUSER_MOVABLE (__GFP_WAIT | __GFP_IO | __GFP_FS | \
|
|
|
|
__GFP_HARDWALL | __GFP_HIGHMEM | \
|
|
|
|
__GFP_MOVABLE)
|
2010-03-05 16:42:13 -05:00
|
|
|
#define GFP_IOFS (__GFP_IO | __GFP_FS)
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2006-09-27 04:50:07 -04:00
|
|
|
#ifdef CONFIG_NUMA
|
2006-09-26 02:31:46 -04:00
|
|
|
#define GFP_THISNODE (__GFP_THISNODE | __GFP_NOWARN | __GFP_NORETRY)
|
2006-09-27 04:50:07 -04:00
|
|
|
#else
|
2007-02-09 11:38:55 -05:00
|
|
|
#define GFP_THISNODE ((__force gfp_t)0)
|
2006-09-27 04:50:07 -04:00
|
|
|
#endif
|
|
|
|
|
2007-10-16 04:25:41 -04:00
|
|
|
/* This mask makes up all the page movable related flags */
|
2007-10-16 04:25:52 -04:00
|
|
|
#define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE)
|
2007-10-16 04:25:41 -04:00
|
|
|
|
|
|
|
/* Control page allocator reclaim behavior */
|
|
|
|
#define GFP_RECLAIM_MASK (__GFP_WAIT|__GFP_HIGH|__GFP_IO|__GFP_FS|\
|
|
|
|
__GFP_NOWARN|__GFP_REPEAT|__GFP_NOFAIL|\
|
|
|
|
__GFP_NORETRY|__GFP_NOMEMALLOC)
|
|
|
|
|
2009-06-12 07:03:06 -04:00
|
|
|
/* Control slab gfp mask during early boot */
|
2009-06-17 23:24:12 -04:00
|
|
|
#define GFP_BOOT_MASK __GFP_BITS_MASK & ~(__GFP_WAIT|__GFP_IO|__GFP_FS)
|
2009-06-12 07:03:06 -04:00
|
|
|
|
2007-10-16 04:25:41 -04:00
|
|
|
/* Control allocation constraints */
|
|
|
|
#define GFP_CONSTRAINT_MASK (__GFP_HARDWALL|__GFP_THISNODE)
|
|
|
|
|
|
|
|
/* Do not use these with a slab allocator */
|
|
|
|
#define GFP_SLAB_BUG_MASK (__GFP_DMA32|__GFP_HIGHMEM|~__GFP_BITS_MASK)
|
2006-09-26 02:31:46 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/* Flag - indicates that the buffer will be suitable for DMA. Ignored on some
|
|
|
|
platforms, used as appropriate on others */
|
|
|
|
|
|
|
|
#define GFP_DMA __GFP_DMA
|
|
|
|
|
2005-11-05 11:25:53 -05:00
|
|
|
/* 4GB DMA on some platforms */
|
|
|
|
#define GFP_DMA32 __GFP_DMA32
|
|
|
|
|
Print out statistics in relation to fragmentation avoidance to /proc/pagetypeinfo
This patch provides fragmentation avoidance statistics via /proc/pagetypeinfo.
The information is collected only on request so there is no runtime overhead.
The statistics are in three parts:
The first part prints information on the size of blocks that pages are
being grouped on and looks like
Page block order: 10
Pages per block: 1024
The second part is a more detailed version of /proc/buddyinfo and looks like
Free pages count per migrate type at order 0 1 2 3 4 5 6 7 8 9 10
Node 0, zone DMA, type Unmovable 0 0 0 0 0 0 0 0 0 0 0
Node 0, zone DMA, type Reclaimable 1 0 0 0 0 0 0 0 0 0 0
Node 0, zone DMA, type Movable 0 0 0 0 0 0 0 0 0 0 0
Node 0, zone DMA, type Reserve 0 4 4 0 0 0 0 1 0 1 0
Node 0, zone Normal, type Unmovable 111 8 4 4 2 3 1 0 0 0 0
Node 0, zone Normal, type Reclaimable 293 89 8 0 0 0 0 0 0 0 0
Node 0, zone Normal, type Movable 1 6 13 9 7 6 3 0 0 0 0
Node 0, zone Normal, type Reserve 0 0 0 0 0 0 0 0 0 0 4
The third part looks like
Number of blocks type Unmovable Reclaimable Movable Reserve
Node 0, zone DMA 0 1 2 1
Node 0, zone Normal 3 17 94 4
To walk the zones within a node with interrupts disabled, walk_zones_in_node()
is introduced and shared between /proc/buddyinfo, /proc/zoneinfo and
/proc/pagetypeinfo to reduce code duplication. It seems specific to what
vmstat.c requires but could be broken out as a general utility function in
mmzone.c if there were other other potential users.
Signed-off-by: Mel Gorman <mel@csn.ul.ie>
Acked-by: Andy Whitcroft <apw@shadowen.org>
Acked-by: Christoph Lameter <clameter@sgi.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 04:26:02 -04:00
|
|
|
/* Convert GFP flags to their corresponding migrate type */
|
|
|
|
static inline int allocflags_to_migratetype(gfp_t gfp_flags)
|
|
|
|
{
|
|
|
|
WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK);
|
|
|
|
|
|
|
|
if (unlikely(page_group_by_mobility_disabled))
|
|
|
|
return MIGRATE_UNMOVABLE;
|
|
|
|
|
|
|
|
/* Group based on mobility */
|
|
|
|
return (((gfp_flags & __GFP_MOVABLE) != 0) << 1) |
|
|
|
|
((gfp_flags & __GFP_RECLAIMABLE) != 0);
|
|
|
|
}
|
2005-11-05 11:25:53 -05:00
|
|
|
|
2009-06-16 18:32:46 -04:00
|
|
|
#ifdef CONFIG_HIGHMEM
|
|
|
|
#define OPT_ZONE_HIGHMEM ZONE_HIGHMEM
|
|
|
|
#else
|
|
|
|
#define OPT_ZONE_HIGHMEM ZONE_NORMAL
|
|
|
|
#endif
|
|
|
|
|
2007-02-10 04:43:10 -05:00
|
|
|
#ifdef CONFIG_ZONE_DMA
|
2009-06-16 18:32:46 -04:00
|
|
|
#define OPT_ZONE_DMA ZONE_DMA
|
|
|
|
#else
|
|
|
|
#define OPT_ZONE_DMA ZONE_NORMAL
|
2007-02-10 04:43:10 -05:00
|
|
|
#endif
|
2009-06-16 18:32:46 -04:00
|
|
|
|
2006-09-26 02:31:17 -04:00
|
|
|
#ifdef CONFIG_ZONE_DMA32
|
2009-06-16 18:32:46 -04:00
|
|
|
#define OPT_ZONE_DMA32 ZONE_DMA32
|
|
|
|
#else
|
|
|
|
#define OPT_ZONE_DMA32 ZONE_NORMAL
|
2006-09-26 02:31:17 -04:00
|
|
|
#endif
|
2009-06-16 18:32:46 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* GFP_ZONE_TABLE is a word size bitstring that is used for looking up the
|
|
|
|
* zone to use given the lowest 4 bits of gfp_t. Entries are ZONE_SHIFT long
|
|
|
|
* and there are 16 of them to cover all possible combinations of
|
|
|
|
* __GFP_DMA, __GFP_DMA32, __GFP_MOVABLE and __GFP_HIGHMEM
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
* Only 1bit of the lowest 3 bit (DMA,DMA32,HIGHMEM) can be set to "1".
|
|
|
|
*
|
|
|
|
* bit result
|
|
|
|
* =================
|
|
|
|
* 0x0 => NORMAL
|
|
|
|
* 0x1 => DMA or NORMAL
|
|
|
|
* 0x2 => HIGHMEM or NORMAL
|
|
|
|
* 0x3 => BAD (DMA+HIGHMEM)
|
|
|
|
* 0x4 => DMA32 or DMA or NORMAL
|
|
|
|
* 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)
|
|
|
|
* 0xc => DMA32 (MOVABLE+HIGHMEM+DMA32)
|
|
|
|
* 0xd => BAD (MOVABLE+DMA32+DMA)
|
|
|
|
* 0xe => BAD (MOVABLE+DMA32+HIGHMEM)
|
|
|
|
* 0xf => BAD (MOVABLE+DMA32+HIGHMEM+DMA)
|
|
|
|
*
|
|
|
|
* ZONES_SHIFT must be <= 2 on 32 bit platforms.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#if 16 * ZONES_SHIFT > BITS_PER_LONG
|
|
|
|
#error ZONES_SHIFT too large to create GFP_ZONE_TABLE integer
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define GFP_ZONE_TABLE ( \
|
|
|
|
(ZONE_NORMAL << 0 * ZONES_SHIFT) \
|
|
|
|
| (OPT_ZONE_DMA << __GFP_DMA * ZONES_SHIFT) \
|
|
|
|
| (OPT_ZONE_HIGHMEM << __GFP_HIGHMEM * ZONES_SHIFT) \
|
|
|
|
| (OPT_ZONE_DMA32 << __GFP_DMA32 * ZONES_SHIFT) \
|
|
|
|
| (ZONE_NORMAL << __GFP_MOVABLE * ZONES_SHIFT) \
|
|
|
|
| (OPT_ZONE_DMA << (__GFP_MOVABLE | __GFP_DMA) * ZONES_SHIFT) \
|
|
|
|
| (ZONE_MOVABLE << (__GFP_MOVABLE | __GFP_HIGHMEM) * ZONES_SHIFT)\
|
|
|
|
| (OPT_ZONE_DMA32 << (__GFP_MOVABLE | __GFP_DMA32) * ZONES_SHIFT)\
|
|
|
|
)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* GFP_ZONE_BAD is a bitmap for all combination of __GFP_DMA, __GFP_DMA32
|
|
|
|
* __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 ( \
|
|
|
|
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)\
|
|
|
|
)
|
|
|
|
|
|
|
|
static inline enum zone_type gfp_zone(gfp_t flags)
|
|
|
|
{
|
|
|
|
enum zone_type z;
|
|
|
|
int bit = flags & GFP_ZONEMASK;
|
|
|
|
|
|
|
|
z = (GFP_ZONE_TABLE >> (bit * ZONES_SHIFT)) &
|
|
|
|
((1 << ZONES_SHIFT) - 1);
|
|
|
|
|
|
|
|
if (__builtin_constant_p(bit))
|
2009-09-22 19:43:52 -04:00
|
|
|
MAYBE_BUILD_BUG_ON((GFP_ZONE_BAD >> bit) & 1);
|
2009-06-16 18:32:46 -04:00
|
|
|
else {
|
|
|
|
#ifdef CONFIG_DEBUG_VM
|
|
|
|
BUG_ON((GFP_ZONE_BAD >> bit) & 1);
|
2006-09-26 02:31:17 -04:00
|
|
|
#endif
|
2009-06-16 18:32:46 -04:00
|
|
|
}
|
|
|
|
return z;
|
2006-09-26 02:31:17 -04:00
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* 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).
|
|
|
|
*/
|
|
|
|
|
2008-04-28 05:12:16 -04:00
|
|
|
static inline int gfp_zonelist(gfp_t flags)
|
|
|
|
{
|
|
|
|
if (NUMA_BUILD && unlikely(flags & __GFP_THISNODE))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* 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.
|
2008-04-28 05:12:16 -04:00
|
|
|
* There are two zonelists per node, one for all zones with memory and
|
|
|
|
* one containing just zones from the node the zonelist belongs to.
|
2005-04-16 18:20:36 -04:00
|
|
|
*
|
|
|
|
* For the normal case of non-DISCONTIGMEM systems the NODE_DATA() gets
|
|
|
|
* optimized to &contig_page_data at compile-time.
|
|
|
|
*/
|
2008-04-28 05:12:14 -04:00
|
|
|
static inline struct zonelist *node_zonelist(int nid, gfp_t flags)
|
|
|
|
{
|
2008-04-28 05:12:16 -04:00
|
|
|
return NODE_DATA(nid)->node_zonelists + gfp_zonelist(flags);
|
2008-04-28 05:12:14 -04:00
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
#ifndef HAVE_ARCH_FREE_PAGE
|
|
|
|
static inline void arch_free_page(struct page *page, int order) { }
|
|
|
|
#endif
|
2006-12-06 23:32:00 -05:00
|
|
|
#ifndef HAVE_ARCH_ALLOC_PAGE
|
|
|
|
static inline void arch_alloc_page(struct page *page, int order) { }
|
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-07-24 00:27:01 -04:00
|
|
|
struct page *
|
2009-06-16 18:31:52 -04:00
|
|
|
__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,
|
2008-07-24 00:27:01 -04:00
|
|
|
struct zonelist *zonelist, nodemask_t *nodemask);
|
|
|
|
|
|
|
|
static inline struct page *
|
|
|
|
__alloc_pages(gfp_t gfp_mask, unsigned int order,
|
|
|
|
struct zonelist *zonelist)
|
|
|
|
{
|
2009-06-16 18:31:52 -04:00
|
|
|
return __alloc_pages_nodemask(gfp_mask, order, zonelist, NULL);
|
2008-07-24 00:27:01 -04:00
|
|
|
}
|
|
|
|
|
2005-10-07 02:46:04 -04:00
|
|
|
static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
|
2005-04-16 18:20:36 -04:00
|
|
|
unsigned int order)
|
|
|
|
{
|
2006-01-11 16:43:45 -05:00
|
|
|
/* Unknown node is current node */
|
|
|
|
if (nid < 0)
|
|
|
|
nid = numa_node_id();
|
|
|
|
|
2008-04-28 05:12:14 -04:00
|
|
|
return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
|
|
|
|
2009-06-16 18:31:54 -04:00
|
|
|
static inline struct page *alloc_pages_exact_node(int nid, gfp_t gfp_mask,
|
|
|
|
unsigned int order)
|
|
|
|
{
|
|
|
|
VM_BUG_ON(nid < 0 || nid >= MAX_NUMNODES);
|
|
|
|
|
|
|
|
return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
|
|
|
|
}
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
#ifdef CONFIG_NUMA
|
2005-10-07 02:46:04 -04:00
|
|
|
extern struct page *alloc_pages_current(gfp_t gfp_mask, unsigned order);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
static inline struct page *
|
2005-10-07 02:46:04 -04:00
|
|
|
alloc_pages(gfp_t gfp_mask, unsigned int order)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
return alloc_pages_current(gfp_mask, order);
|
|
|
|
}
|
2005-10-07 02:46:04 -04:00
|
|
|
extern struct page *alloc_page_vma(gfp_t gfp_mask,
|
2005-04-16 18:20:36 -04:00
|
|
|
struct vm_area_struct *vma, unsigned long addr);
|
|
|
|
#else
|
|
|
|
#define alloc_pages(gfp_mask, order) \
|
|
|
|
alloc_pages_node(numa_node_id(), gfp_mask, order)
|
|
|
|
#define alloc_page_vma(gfp_mask, vma, addr) alloc_pages(gfp_mask, 0)
|
|
|
|
#endif
|
|
|
|
#define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)
|
|
|
|
|
2008-02-13 18:03:15 -05:00
|
|
|
extern unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);
|
|
|
|
extern unsigned long get_zeroed_page(gfp_t gfp_mask);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2008-07-24 00:28:11 -04:00
|
|
|
void *alloc_pages_exact(size_t size, gfp_t gfp_mask);
|
|
|
|
void free_pages_exact(void *virt, size_t size);
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
#define __get_free_page(gfp_mask) \
|
|
|
|
__get_free_pages((gfp_mask),0)
|
|
|
|
|
|
|
|
#define __get_dma_pages(gfp_mask, order) \
|
|
|
|
__get_free_pages((gfp_mask) | GFP_DMA,(order))
|
|
|
|
|
2008-02-13 18:03:15 -05:00
|
|
|
extern void __free_pages(struct page *page, unsigned int order);
|
|
|
|
extern void free_pages(unsigned long addr, unsigned int order);
|
2010-03-05 16:41:54 -05:00
|
|
|
extern void free_hot_cold_page(struct page *page, int cold);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
#define __free_page(page) __free_pages((page), 0)
|
|
|
|
#define free_page(addr) free_pages((addr),0)
|
|
|
|
|
|
|
|
void page_alloc_init(void);
|
2007-05-09 05:35:14 -04:00
|
|
|
void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp);
|
2008-02-05 01:29:11 -05:00
|
|
|
void drain_all_pages(void);
|
|
|
|
void drain_local_pages(void *dummy);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2009-06-17 23:24:12 -04:00
|
|
|
extern gfp_t gfp_allowed_mask;
|
|
|
|
|
2010-03-05 16:42:13 -05:00
|
|
|
extern void set_gfp_allowed_mask(gfp_t mask);
|
|
|
|
extern gfp_t clear_gfp_allowed_mask(gfp_t mask);
|
2009-06-17 23:24:12 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
#endif /* __LINUX_GFP_H */
|