Merge branches 'x86-build-for-linus', 'x86-cleanups-for-linus' and 'x86-debug-for...
[linux-2.6-microblaze.git] / include / linux / balloon_compaction.h
1 /*
2  * include/linux/balloon_compaction.h
3  *
4  * Common interface definitions for making balloon pages movable by compaction.
5  *
6  * Despite being perfectly possible to perform ballooned pages migration, they
7  * make a special corner case to compaction scans because balloon pages are not
8  * enlisted at any LRU list like the other pages we do compact / migrate.
9  *
10  * As the page isolation scanning step a compaction thread does is a lockless
11  * procedure (from a page standpoint), it might bring some racy situations while
12  * performing balloon page compaction. In order to sort out these racy scenarios
13  * and safely perform balloon's page compaction and migration we must, always,
14  * ensure following these three simple rules:
15  *
16  *   i. when updating a balloon's page ->mapping element, strictly do it under
17  *      the following lock order, independently of the far superior
18  *      locking scheme (lru_lock, balloon_lock):
19  *          +-page_lock(page);
20  *            +--spin_lock_irq(&b_dev_info->pages_lock);
21  *                  ... page->mapping updates here ...
22  *
23  *  ii. before isolating or dequeueing a balloon page from the balloon device
24  *      pages list, the page reference counter must be raised by one and the
25  *      extra refcount must be dropped when the page is enqueued back into
26  *      the balloon device page list, thus a balloon page keeps its reference
27  *      counter raised only while it is under our special handling;
28  *
29  * iii. after the lockless scan step have selected a potential balloon page for
30  *      isolation, re-test the PageBalloon mark and the PagePrivate flag
31  *      under the proper page lock, to ensure isolating a valid balloon page
32  *      (not yet isolated, nor under release procedure)
33  *
34  *  iv. isolation or dequeueing procedure must clear PagePrivate flag under
35  *      page lock together with removing page from balloon device page list.
36  *
37  * The functions provided by this interface are placed to help on coping with
38  * the aforementioned balloon page corner case, as well as to ensure the simple
39  * set of exposed rules are satisfied while we are dealing with balloon pages
40  * compaction / migration.
41  *
42  * Copyright (C) 2012, Red Hat, Inc.  Rafael Aquini <aquini@redhat.com>
43  */
44 #ifndef _LINUX_BALLOON_COMPACTION_H
45 #define _LINUX_BALLOON_COMPACTION_H
46 #include <linux/pagemap.h>
47 #include <linux/page-flags.h>
48 #include <linux/migrate.h>
49 #include <linux/gfp.h>
50 #include <linux/err.h>
51
52 /*
53  * Balloon device information descriptor.
54  * This struct is used to allow the common balloon compaction interface
55  * procedures to find the proper balloon device holding memory pages they'll
56  * have to cope for page compaction / migration, as well as it serves the
57  * balloon driver as a page book-keeper for its registered balloon devices.
58  */
59 struct balloon_dev_info {
60         unsigned long isolated_pages;   /* # of isolated pages for migration */
61         spinlock_t pages_lock;          /* Protection to pages list */
62         struct list_head pages;         /* Pages enqueued & handled to Host */
63         int (*migratepage)(struct balloon_dev_info *, struct page *newpage,
64                         struct page *page, enum migrate_mode mode);
65 };
66
67 extern struct page *balloon_page_enqueue(struct balloon_dev_info *b_dev_info);
68 extern struct page *balloon_page_dequeue(struct balloon_dev_info *b_dev_info);
69
70 static inline void balloon_devinfo_init(struct balloon_dev_info *balloon)
71 {
72         balloon->isolated_pages = 0;
73         spin_lock_init(&balloon->pages_lock);
74         INIT_LIST_HEAD(&balloon->pages);
75         balloon->migratepage = NULL;
76 }
77
78 #ifdef CONFIG_BALLOON_COMPACTION
79 extern bool balloon_page_isolate(struct page *page);
80 extern void balloon_page_putback(struct page *page);
81 extern int balloon_page_migrate(struct page *newpage,
82                                 struct page *page, enum migrate_mode mode);
83
84 /*
85  * __is_movable_balloon_page - helper to perform @page PageBalloon tests
86  */
87 static inline bool __is_movable_balloon_page(struct page *page)
88 {
89         return PageBalloon(page);
90 }
91
92 /*
93  * balloon_page_movable - test PageBalloon to identify balloon pages
94  *                        and PagePrivate to check that the page is not
95  *                        isolated and can be moved by compaction/migration.
96  *
97  * As we might return false positives in the case of a balloon page being just
98  * released under us, this need to be re-tested later, under the page lock.
99  */
100 static inline bool balloon_page_movable(struct page *page)
101 {
102         return PageBalloon(page) && PagePrivate(page);
103 }
104
105 /*
106  * isolated_balloon_page - identify an isolated balloon page on private
107  *                         compaction/migration page lists.
108  */
109 static inline bool isolated_balloon_page(struct page *page)
110 {
111         return PageBalloon(page);
112 }
113
114 /*
115  * balloon_page_insert - insert a page into the balloon's page list and make
116  *                       the page->private assignment accordingly.
117  * @balloon : pointer to balloon device
118  * @page    : page to be assigned as a 'balloon page'
119  *
120  * Caller must ensure the page is locked and the spin_lock protecting balloon
121  * pages list is held before inserting a page into the balloon device.
122  */
123 static inline void balloon_page_insert(struct balloon_dev_info *balloon,
124                                        struct page *page)
125 {
126         __SetPageBalloon(page);
127         SetPagePrivate(page);
128         set_page_private(page, (unsigned long)balloon);
129         list_add(&page->lru, &balloon->pages);
130 }
131
132 /*
133  * balloon_page_delete - delete a page from balloon's page list and clear
134  *                       the page->private assignement accordingly.
135  * @page    : page to be released from balloon's page list
136  *
137  * Caller must ensure the page is locked and the spin_lock protecting balloon
138  * pages list is held before deleting a page from the balloon device.
139  */
140 static inline void balloon_page_delete(struct page *page)
141 {
142         __ClearPageBalloon(page);
143         set_page_private(page, 0);
144         if (PagePrivate(page)) {
145                 ClearPagePrivate(page);
146                 list_del(&page->lru);
147         }
148 }
149
150 /*
151  * balloon_page_device - get the b_dev_info descriptor for the balloon device
152  *                       that enqueues the given page.
153  */
154 static inline struct balloon_dev_info *balloon_page_device(struct page *page)
155 {
156         return (struct balloon_dev_info *)page_private(page);
157 }
158
159 static inline gfp_t balloon_mapping_gfp_mask(void)
160 {
161         return GFP_HIGHUSER_MOVABLE;
162 }
163
164 #else /* !CONFIG_BALLOON_COMPACTION */
165
166 static inline void balloon_page_insert(struct balloon_dev_info *balloon,
167                                        struct page *page)
168 {
169         __SetPageBalloon(page);
170         list_add(&page->lru, &balloon->pages);
171 }
172
173 static inline void balloon_page_delete(struct page *page)
174 {
175         __ClearPageBalloon(page);
176         list_del(&page->lru);
177 }
178
179 static inline bool __is_movable_balloon_page(struct page *page)
180 {
181         return false;
182 }
183
184 static inline bool balloon_page_movable(struct page *page)
185 {
186         return false;
187 }
188
189 static inline bool isolated_balloon_page(struct page *page)
190 {
191         return false;
192 }
193
194 static inline bool balloon_page_isolate(struct page *page)
195 {
196         return false;
197 }
198
199 static inline void balloon_page_putback(struct page *page)
200 {
201         return;
202 }
203
204 static inline int balloon_page_migrate(struct page *newpage,
205                                 struct page *page, enum migrate_mode mode)
206 {
207         return 0;
208 }
209
210 static inline gfp_t balloon_mapping_gfp_mask(void)
211 {
212         return GFP_HIGHUSER;
213 }
214
215 #endif /* CONFIG_BALLOON_COMPACTION */
216 #endif /* _LINUX_BALLOON_COMPACTION_H */