Subversion Repositories Kolibri OS

#ifndef __LINUX_GFP_H

#define __LINUX_GFP_H

#include 

#include 

#include 

#include 

struct vm_area_struct;

/* 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

#define ___GFP_WAIT		0x10u

#define ___GFP_HIGH		0x20u

#define ___GFP_IO		0x40u

#define ___GFP_FS		0x80u

#define ___GFP_COLD		0x100u

#define ___GFP_NOWARN		0x200u

#define ___GFP_REPEAT		0x400u

#define ___GFP_NOFAIL		0x800u

#define ___GFP_NORETRY		0x1000u

#define ___GFP_MEMALLOC		0x2000u

#define ___GFP_COMP		0x4000u

#define ___GFP_ZERO		0x8000u

#define ___GFP_NOMEMALLOC	0x10000u

#define ___GFP_HARDWALL		0x20000u

#define ___GFP_THISNODE		0x40000u

#define ___GFP_RECLAIMABLE	0x80000u

#define ___GFP_NOTRACK		0x200000u

#define ___GFP_NO_KSWAPD	0x400000u

#define ___GFP_OTHER_NODE	0x800000u

#define ___GFP_WRITE		0x1000000u

/* If the above are modified, __GFP_BITS_SHIFT may need updating */

/*

 * GFP bitmasks..

 *

 * 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 them consistently. The definitions here may

 * be used in bit comparisons.

 */

#define __GFP_DMA	((__force gfp_t)___GFP_DMA)

#define __GFP_HIGHMEM	((__force gfp_t)___GFP_HIGHMEM)

#define __GFP_DMA32	((__force gfp_t)___GFP_DMA32)

#define __GFP_MOVABLE	((__force gfp_t)___GFP_MOVABLE)  /* Page is movable */

#define GFP_ZONEMASK	(__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)

/*

 * 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

 * cannot handle allocation failures.  This modifier is deprecated and no new

 * users should be added.

 *

 * __GFP_NORETRY: The VM implementation must not retry indefinitely.

 *

 * __GFP_MOVABLE: Flag that this page will be movable by the page migration

 * mechanism or reclaimed

 */

#define __GFP_WAIT	((__force gfp_t)___GFP_WAIT)	/* Can wait and reschedule? */

#define __GFP_HIGH	((__force gfp_t)___GFP_HIGH)	/* Should access emergency pools? */

#define __GFP_IO	((__force gfp_t)___GFP_IO)	/* Can start physical IO? */

#define __GFP_FS	((__force gfp_t)___GFP_FS)	/* Can call down to low-level FS? */

#define __GFP_COLD	((__force gfp_t)___GFP_COLD)	/* Cache-cold page required */

#define __GFP_NOWARN	((__force gfp_t)___GFP_NOWARN)	/* Suppress page allocation failure warning */

#define __GFP_REPEAT	((__force gfp_t)___GFP_REPEAT)	/* See above */

#define __GFP_NOFAIL	((__force gfp_t)___GFP_NOFAIL)	/* See above */

#define __GFP_NORETRY	((__force gfp_t)___GFP_NORETRY) /* See above */

#define __GFP_MEMALLOC	((__force gfp_t)___GFP_MEMALLOC)/* Allow access to emergency reserves */

#define __GFP_COMP	((__force gfp_t)___GFP_COMP)	/* Add compound page metadata */

#define __GFP_ZERO	((__force gfp_t)___GFP_ZERO)	/* Return zeroed page on success */

#define __GFP_NOMEMALLOC ((__force gfp_t)___GFP_NOMEMALLOC) /* Don't use emergency reserves.

							 * This takes precedence over the

							 * __GFP_MEMALLOC flag if both are

							 * set

							 */

#define __GFP_HARDWALL   ((__force gfp_t)___GFP_HARDWALL) /* Enforce hardwall cpuset memory allocs */

#define __GFP_THISNODE	((__force gfp_t)___GFP_THISNODE)/* No fallback, no policies */

#define __GFP_RECLAIMABLE ((__force gfp_t)___GFP_RECLAIMABLE) /* Page is reclaimable */

#define __GFP_NOTRACK	((__force gfp_t)___GFP_NOTRACK)  /* Don't track with kmemcheck */

#define __GFP_NO_KSWAPD	((__force gfp_t)___GFP_NO_KSWAPD)

#define __GFP_OTHER_NODE ((__force gfp_t)___GFP_OTHER_NODE) /* On behalf of other node */

#define __GFP_WRITE	((__force gfp_t)___GFP_WRITE)	/* Allocator intends to dirty page */

/*

 * 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 25	/* Room for N __GFP_FOO bits */

#define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))

/* This equals 0, but use constants in case they ever change */

#define GFP_NOWAIT	(GFP_ATOMIC & ~__GFP_HIGH)

/* GFP_ATOMIC means both !wait (__GFP_WAIT not set) and use emergency pool */

#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)

#define GFP_TEMPORARY	(__GFP_WAIT | __GFP_IO | __GFP_FS | \

			 __GFP_RECLAIMABLE)

#define GFP_USER	(__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL)

#define GFP_HIGHUSER	(GFP_USER | __GFP_HIGHMEM)

#define GFP_HIGHUSER_MOVABLE	(GFP_HIGHUSER | __GFP_MOVABLE)

#define GFP_IOFS	(__GFP_IO | __GFP_FS)

#define GFP_TRANSHUGE	(GFP_HIGHUSER_MOVABLE | __GFP_COMP | \

			 __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN | \

			 __GFP_NO_KSWAPD)

/*

 * GFP_THISNODE does not perform any reclaim, you most likely want to

 * use __GFP_THISNODE to allocate from a given node without fallback!

 */

#ifdef CONFIG_NUMA

#define GFP_THISNODE	(__GFP_THISNODE | __GFP_NOWARN | __GFP_NORETRY)

#else

#define GFP_THISNODE	((__force gfp_t)0)

#endif

/* This mask makes up all the page movable related flags */

#define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE)

/* 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_MEMALLOC|__GFP_NOMEMALLOC)

/* Control slab gfp mask during early boot */

#define GFP_BOOT_MASK (__GFP_BITS_MASK & ~(__GFP_WAIT|__GFP_IO|__GFP_FS))

/* 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)

/* Flag - indicates that the buffer will be suitable for DMA.  Ignored on some

   platforms, used as appropriate on others */

#define GFP_DMA		__GFP_DMA

/* 4GB DMA on some platforms */

#define GFP_DMA32	__GFP_DMA32

#ifdef CONFIG_HIGHMEM

#define OPT_ZONE_HIGHMEM ZONE_HIGHMEM

#else

#define OPT_ZONE_HIGHMEM ZONE_NORMAL

#endif

#ifdef CONFIG_ZONE_DMA

#define OPT_ZONE_DMA ZONE_DMA

#else

#define OPT_ZONE_DMA ZONE_NORMAL

#endif

#ifdef CONFIG_ZONE_DMA32

#define OPT_ZONE_DMA32 ZONE_DMA32

#else

#define OPT_ZONE_DMA32 ZONE_NORMAL

#endif

/*

 * 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 1 bit of the lowest 3 bits (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+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 combinations 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)  \

)

#endif /* __LINUX_GFP_H */