← Back to branch summary

~ubuntu-branches/ubuntu/utopic/xen/utopic

« back to all changes in this revision

Viewing changes to xen/include/asm-ia64/linux-xen/linux/gfp.h

  • Committer: Bazaar Package Importer
  • Author(s): Bastian Blank
  • Date: 2010-05-06 15:47:38 UTC
  • mto: (1.3.1) (15.1.1 sid) (4.1.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20100506154738-agoz0rlafrh1fnq7
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
xen/include/asm-ia64/linux-xen/linux/gfp.h
 
1
#ifndef __LINUX_GFP_H
 
2
#define __LINUX_GFP_H
 
3
 
 
4
#ifdef XEN
 
5
#include <asm/bitops.h>
 
6
#include <linux/topology.h>
 
7
#endif
 
8
#include <linux/mmzone.h>
 
9
#include <linux/stddef.h>
 
10
#include <linux/linkage.h>
 
11
#include <linux/config.h>
 
12
 
 
13
struct vm_area_struct;
 
14
 
 
15
/*
 
16
 * GFP bitmasks..
 
17
 */
 
18
/* Zone modifiers in GFP_ZONEMASK (see linux/mmzone.h - low two bits) */
 
19
#define __GFP_DMA       0x01u
 
20
#define __GFP_HIGHMEM   0x02u
 
21
 
 
22
/*
 
23
 * Action modifiers - doesn't change the zoning
 
24
 *
 
25
 * __GFP_REPEAT: Try hard to allocate the memory, but the allocation attempt
 
26
 * _might_ fail.  This depends upon the particular VM implementation.
 
27
 *
 
28
 * __GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller
 
29
 * cannot handle allocation failures.
 
30
 *
 
31
 * __GFP_NORETRY: The VM implementation must not retry indefinitely.
 
32
 */
 
33
#define __GFP_WAIT      0x10u   /* Can wait and reschedule? */
 
34
#define __GFP_HIGH      0x20u   /* Should access emergency pools? */
 
35
#define __GFP_IO        0x40u   /* Can start physical IO? */
 
36
#define __GFP_FS        0x80u   /* Can call down to low-level FS? */
 
37
#define __GFP_COLD      0x100u  /* Cache-cold page required */
 
38
#define __GFP_NOWARN    0x200u  /* Suppress page allocation failure warning */
 
39
#define __GFP_REPEAT    0x400u  /* Retry the allocation.  Might fail */
 
40
#define __GFP_NOFAIL    0x800u  /* Retry for ever.  Cannot fail */
 
41
#define __GFP_NORETRY   0x1000u /* Do not retry.  Might fail */
 
42
#define __GFP_NO_GROW   0x2000u /* Slab internal usage */
 
43
#define __GFP_COMP      0x4000u /* Add compound page metadata */
 
44
#define __GFP_ZERO      0x8000u /* Return zeroed page on success */
 
45
#define __GFP_NOMEMALLOC 0x10000u /* Don't use emergency reserves */
 
46
#define __GFP_NORECLAIM  0x20000u /* No realy zone reclaim during allocation */
 
47
 
 
48
#define __GFP_BITS_SHIFT 20     /* Room for 20 __GFP_FOO bits */
 
49
#define __GFP_BITS_MASK ((1 << __GFP_BITS_SHIFT) - 1)
 
50
 
 
51
/* if you forget to add the bitmask here kernel will crash, period */
 
52
#define GFP_LEVEL_MASK (__GFP_WAIT|__GFP_HIGH|__GFP_IO|__GFP_FS| \
 
53
                        __GFP_COLD|__GFP_NOWARN|__GFP_REPEAT| \
 
54
                        __GFP_NOFAIL|__GFP_NORETRY|__GFP_NO_GROW|__GFP_COMP| \
 
55
                        __GFP_NOMEMALLOC|__GFP_NORECLAIM)
 
56
 
 
57
#define GFP_ATOMIC      (__GFP_HIGH)
 
58
#define GFP_NOIO        (__GFP_WAIT)
 
59
#define GFP_NOFS        (__GFP_WAIT | __GFP_IO)
 
60
#define GFP_KERNEL      (__GFP_WAIT | __GFP_IO | __GFP_FS)
 
61
#define GFP_USER        (__GFP_WAIT | __GFP_IO | __GFP_FS)
 
62
#define GFP_HIGHUSER    (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HIGHMEM)
 
63
 
 
64
/* Flag - indicates that the buffer will be suitable for DMA.  Ignored on some
 
65
   platforms, used as appropriate on others */
 
66
 
 
67
#define GFP_DMA         __GFP_DMA
 
68
 
 
69
 
 
70
/*
 
71
 * There is only one page-allocator function, and two main namespaces to
 
72
 * it. The alloc_page*() variants return 'struct page *' and as such
 
73
 * can allocate highmem pages, the *get*page*() variants return
 
74
 * virtual kernel addresses to the allocated page(s).
 
75
 */
 
76
 
 
77
/*
 
78
 * We get the zone list from the current node and the gfp_mask.
 
79
 * This zone list contains a maximum of MAXNODES*MAX_NR_ZONES zones.
 
80
 *
 
81
 * For the normal case of non-DISCONTIGMEM systems the NODE_DATA() gets
 
82
 * optimized to &contig_page_data at compile-time.
 
83
 */
 
84
 
 
85
#ifndef XEN
 
86
#ifndef HAVE_ARCH_FREE_PAGE
 
87
static inline void arch_free_page(struct page *page, int order) { }
 
88
#endif
 
89
 
 
90
extern struct page *
 
91
FASTCALL(__alloc_pages(unsigned int, unsigned int, struct zonelist *));
 
92
 
 
93
static inline struct page *alloc_pages_node(int nid, unsigned int __nocast gfp_mask,
 
94
                                                unsigned int order)
 
95
{
 
96
        if (unlikely(order >= MAX_ORDER))
 
97
                return NULL;
 
98
 
 
99
        return __alloc_pages(gfp_mask, order,
 
100
                NODE_DATA(nid)->node_zonelists + (gfp_mask & GFP_ZONEMASK));
 
101
}
 
102
 
 
103
#ifdef CONFIG_NUMA
 
104
extern struct page *alloc_pages_current(unsigned int __nocast gfp_mask, unsigned order);
 
105
 
 
106
static inline struct page *
 
107
alloc_pages(unsigned int __nocast gfp_mask, unsigned int order)
 
108
{
 
109
        if (unlikely(order >= MAX_ORDER))
 
110
                return NULL;
 
111
 
 
112
        return alloc_pages_current(gfp_mask, order);
 
113
}
 
114
extern struct page *alloc_page_vma(unsigned __nocast gfp_mask,
 
115
                        struct vm_area_struct *vma, unsigned long addr);
 
116
#else
 
117
#define alloc_pages(gfp_mask, order) \
 
118
                alloc_pages_node(numa_node_id(), gfp_mask, order)
 
119
#define alloc_page_vma(gfp_mask, vma, addr) alloc_pages(gfp_mask, 0)
 
120
#endif
 
121
#define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)
 
122
 
 
123
extern unsigned long FASTCALL(__get_free_pages(unsigned int __nocast gfp_mask, unsigned int order));
 
124
extern unsigned long FASTCALL(get_zeroed_page(unsigned int __nocast gfp_mask));
 
125
 
 
126
#define __get_free_page(gfp_mask) \
 
127
                __get_free_pages((gfp_mask),0)
 
128
 
 
129
#define __get_dma_pages(gfp_mask, order) \
 
130
                __get_free_pages((gfp_mask) | GFP_DMA,(order))
 
131
 
 
132
extern void FASTCALL(__free_pages(struct page *page, unsigned int order));
 
133
extern void FASTCALL(free_pages(unsigned long addr, unsigned int order));
 
134
extern void FASTCALL(free_hot_page(struct page *page));
 
135
extern void FASTCALL(free_cold_page(struct page *page));
 
136
 
 
137
#define __free_page(page) __free_pages((page), 0)
 
138
#define free_page(addr) free_pages((addr),0)
 
139
#endif /* XEN */
 
140
 
 
141
void page_alloc_init(void);
 
142
#ifdef CONFIG_NUMA
 
143
void drain_remote_pages(void);
 
144
#else
 
145
static inline void drain_remote_pages(void) { };
 
146
#endif
 
147
 
 
148
#endif /* __LINUX_GFP_H */