blob: 388c2bb9b55cff8e8b89cac1947bf87ef1c83cd7 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Generic hugetlb support.
Nadia Yvette Chambers6d49e352012-12-06 10:39:54 +01003 * (C) Nadia Yvette Chambers, April 2004
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07005#include <linux/list.h>
6#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007#include <linux/mm.h>
Alexey Dobriyane1759c22008-10-15 23:50:22 +04008#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/sysctl.h>
10#include <linux/highmem.h>
Andrea Arcangelicddb8a52008-07-28 15:46:29 -070011#include <linux/mmu_notifier.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/nodemask.h>
David Gibson63551ae2005-06-21 17:14:44 -070013#include <linux/pagemap.h>
Christoph Lameter5da7ca82006-01-06 00:10:46 -080014#include <linux/mempolicy.h>
Gideon Israel Dsouza3b321232014-04-07 15:37:26 -070015#include <linux/compiler.h>
Christoph Lameteraea47ff2006-01-08 01:00:57 -080016#include <linux/cpuset.h>
David Gibson3935baa2006-03-22 00:08:53 -080017#include <linux/mutex.h>
Andi Kleenaa888a72008-07-23 21:27:47 -070018#include <linux/bootmem.h>
Nishanth Aravamudana3437872008-07-23 21:27:44 -070019#include <linux/sysfs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090020#include <linux/slab.h>
Naoya Horiguchi0fe6e202010-05-28 09:29:16 +090021#include <linux/rmap.h>
Naoya Horiguchifd6a03e2010-05-28 09:29:21 +090022#include <linux/swap.h>
23#include <linux/swapops.h>
Naoya Horiguchic8721bb2013-09-11 14:22:09 -070024#include <linux/page-isolation.h>
Davidlohr Bueso8382d912014-04-03 14:47:31 -070025#include <linux/jhash.h>
Linus Torvaldsd6606682008-08-06 12:04:54 -070026
David Gibson63551ae2005-06-21 17:14:44 -070027#include <asm/page.h>
28#include <asm/pgtable.h>
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -070029#include <asm/tlb.h>
David Gibson63551ae2005-06-21 17:14:44 -070030
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -070031#include <linux/io.h>
David Gibson63551ae2005-06-21 17:14:44 -070032#include <linux/hugetlb.h>
Aneesh Kumar K.V9dd540e2012-07-31 16:42:15 -070033#include <linux/hugetlb_cgroup.h>
Lee Schermerhorn9a3052302009-12-14 17:58:25 -080034#include <linux/node.h>
Nick Piggin7835e982006-03-22 00:08:40 -080035#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
Andrey Ryabinin753162c2015-02-10 14:11:36 -080037int hugepages_treat_as_movable;
Andi Kleena5516432008-07-23 21:27:41 -070038
Aneesh Kumar K.Vc3f38a32012-07-31 16:42:10 -070039int hugetlb_max_hstate __read_mostly;
Andi Kleene5ff2152008-07-23 21:27:42 -070040unsigned int default_hstate_idx;
41struct hstate hstates[HUGE_MAX_HSTATE];
Naoya Horiguchi641844f2015-06-24 16:56:59 -070042/*
43 * Minimum page order among possible hugepage sizes, set to a proper value
44 * at boot time.
45 */
46static unsigned int minimum_order __read_mostly = UINT_MAX;
Andi Kleene5ff2152008-07-23 21:27:42 -070047
Jon Tollefson53ba51d2008-07-23 21:27:52 -070048__initdata LIST_HEAD(huge_boot_pages);
49
Andi Kleene5ff2152008-07-23 21:27:42 -070050/* for command line parsing */
51static struct hstate * __initdata parsed_hstate;
52static unsigned long __initdata default_hstate_max_huge_pages;
Nick Piggine11bfbf2008-07-23 21:27:52 -070053static unsigned long __initdata default_hstate_size;
Vaishali Thakkar9fee0212016-05-19 17:11:04 -070054static bool __initdata parsed_valid_hugepagesz = true;
Andi Kleene5ff2152008-07-23 21:27:42 -070055
David Gibson3935baa2006-03-22 00:08:53 -080056/*
Naoya Horiguchi31caf662013-09-11 14:21:59 -070057 * Protects updates to hugepage_freelists, hugepage_activelist, nr_huge_pages,
58 * free_huge_pages, and surplus_huge_pages.
David Gibson3935baa2006-03-22 00:08:53 -080059 */
Aneesh Kumar K.Vc3f38a32012-07-31 16:42:10 -070060DEFINE_SPINLOCK(hugetlb_lock);
Eric Paris0bd0f9f2005-11-21 21:32:28 -080061
Davidlohr Bueso8382d912014-04-03 14:47:31 -070062/*
63 * Serializes faults on the same logical page. This is used to
64 * prevent spurious OOMs when the hugepage pool is fully utilized.
65 */
66static int num_fault_mutexes;
Mike Kravetzc672c7f2015-09-08 15:01:35 -070067struct mutex *hugetlb_fault_mutex_table ____cacheline_aligned_in_smp;
Davidlohr Bueso8382d912014-04-03 14:47:31 -070068
Mike Kravetz7ca02d02015-04-15 16:13:42 -070069/* Forward declaration */
70static int hugetlb_acct_memory(struct hstate *h, long delta);
71
David Gibson90481622012-03-21 16:34:12 -070072static inline void unlock_or_release_subpool(struct hugepage_subpool *spool)
73{
74 bool free = (spool->count == 0) && (spool->used_hpages == 0);
75
76 spin_unlock(&spool->lock);
77
78 /* If no pages are used, and no other handles to the subpool
Mike Kravetz7ca02d02015-04-15 16:13:42 -070079 * remain, give up any reservations mased on minimum size and
80 * free the subpool */
81 if (free) {
82 if (spool->min_hpages != -1)
83 hugetlb_acct_memory(spool->hstate,
84 -spool->min_hpages);
David Gibson90481622012-03-21 16:34:12 -070085 kfree(spool);
Mike Kravetz7ca02d02015-04-15 16:13:42 -070086 }
David Gibson90481622012-03-21 16:34:12 -070087}
88
Mike Kravetz7ca02d02015-04-15 16:13:42 -070089struct hugepage_subpool *hugepage_new_subpool(struct hstate *h, long max_hpages,
90 long min_hpages)
David Gibson90481622012-03-21 16:34:12 -070091{
92 struct hugepage_subpool *spool;
93
Mike Kravetzc6a91822015-04-15 16:13:36 -070094 spool = kzalloc(sizeof(*spool), GFP_KERNEL);
David Gibson90481622012-03-21 16:34:12 -070095 if (!spool)
96 return NULL;
97
98 spin_lock_init(&spool->lock);
99 spool->count = 1;
Mike Kravetz7ca02d02015-04-15 16:13:42 -0700100 spool->max_hpages = max_hpages;
101 spool->hstate = h;
102 spool->min_hpages = min_hpages;
103
104 if (min_hpages != -1 && hugetlb_acct_memory(h, min_hpages)) {
105 kfree(spool);
106 return NULL;
107 }
108 spool->rsv_hpages = min_hpages;
David Gibson90481622012-03-21 16:34:12 -0700109
110 return spool;
111}
112
113void hugepage_put_subpool(struct hugepage_subpool *spool)
114{
115 spin_lock(&spool->lock);
116 BUG_ON(!spool->count);
117 spool->count--;
118 unlock_or_release_subpool(spool);
119}
120
Mike Kravetz1c5ecae2015-04-15 16:13:39 -0700121/*
122 * Subpool accounting for allocating and reserving pages.
123 * Return -ENOMEM if there are not enough resources to satisfy the
124 * the request. Otherwise, return the number of pages by which the
125 * global pools must be adjusted (upward). The returned value may
126 * only be different than the passed value (delta) in the case where
127 * a subpool minimum size must be manitained.
128 */
129static long hugepage_subpool_get_pages(struct hugepage_subpool *spool,
David Gibson90481622012-03-21 16:34:12 -0700130 long delta)
131{
Mike Kravetz1c5ecae2015-04-15 16:13:39 -0700132 long ret = delta;
David Gibson90481622012-03-21 16:34:12 -0700133
134 if (!spool)
Mike Kravetz1c5ecae2015-04-15 16:13:39 -0700135 return ret;
David Gibson90481622012-03-21 16:34:12 -0700136
137 spin_lock(&spool->lock);
David Gibson90481622012-03-21 16:34:12 -0700138
Mike Kravetz1c5ecae2015-04-15 16:13:39 -0700139 if (spool->max_hpages != -1) { /* maximum size accounting */
140 if ((spool->used_hpages + delta) <= spool->max_hpages)
141 spool->used_hpages += delta;
142 else {
143 ret = -ENOMEM;
144 goto unlock_ret;
145 }
146 }
147
Mike Kravetz09a95e22016-05-19 17:11:01 -0700148 /* minimum size accounting */
149 if (spool->min_hpages != -1 && spool->rsv_hpages) {
Mike Kravetz1c5ecae2015-04-15 16:13:39 -0700150 if (delta > spool->rsv_hpages) {
151 /*
152 * Asking for more reserves than those already taken on
153 * behalf of subpool. Return difference.
154 */
155 ret = delta - spool->rsv_hpages;
156 spool->rsv_hpages = 0;
157 } else {
158 ret = 0; /* reserves already accounted for */
159 spool->rsv_hpages -= delta;
160 }
161 }
162
163unlock_ret:
164 spin_unlock(&spool->lock);
David Gibson90481622012-03-21 16:34:12 -0700165 return ret;
166}
167
Mike Kravetz1c5ecae2015-04-15 16:13:39 -0700168/*
169 * Subpool accounting for freeing and unreserving pages.
170 * Return the number of global page reservations that must be dropped.
171 * The return value may only be different than the passed value (delta)
172 * in the case where a subpool minimum size must be maintained.
173 */
174static long hugepage_subpool_put_pages(struct hugepage_subpool *spool,
David Gibson90481622012-03-21 16:34:12 -0700175 long delta)
176{
Mike Kravetz1c5ecae2015-04-15 16:13:39 -0700177 long ret = delta;
178
David Gibson90481622012-03-21 16:34:12 -0700179 if (!spool)
Mike Kravetz1c5ecae2015-04-15 16:13:39 -0700180 return delta;
David Gibson90481622012-03-21 16:34:12 -0700181
182 spin_lock(&spool->lock);
Mike Kravetz1c5ecae2015-04-15 16:13:39 -0700183
184 if (spool->max_hpages != -1) /* maximum size accounting */
185 spool->used_hpages -= delta;
186
Mike Kravetz09a95e22016-05-19 17:11:01 -0700187 /* minimum size accounting */
188 if (spool->min_hpages != -1 && spool->used_hpages < spool->min_hpages) {
Mike Kravetz1c5ecae2015-04-15 16:13:39 -0700189 if (spool->rsv_hpages + delta <= spool->min_hpages)
190 ret = 0;
191 else
192 ret = spool->rsv_hpages + delta - spool->min_hpages;
193
194 spool->rsv_hpages += delta;
195 if (spool->rsv_hpages > spool->min_hpages)
196 spool->rsv_hpages = spool->min_hpages;
197 }
198
199 /*
200 * If hugetlbfs_put_super couldn't free spool due to an outstanding
201 * quota reference, free it now.
202 */
David Gibson90481622012-03-21 16:34:12 -0700203 unlock_or_release_subpool(spool);
Mike Kravetz1c5ecae2015-04-15 16:13:39 -0700204
205 return ret;
David Gibson90481622012-03-21 16:34:12 -0700206}
207
208static inline struct hugepage_subpool *subpool_inode(struct inode *inode)
209{
210 return HUGETLBFS_SB(inode->i_sb)->spool;
211}
212
213static inline struct hugepage_subpool *subpool_vma(struct vm_area_struct *vma)
214{
Al Viro496ad9a2013-01-23 17:07:38 -0500215 return subpool_inode(file_inode(vma->vm_file));
David Gibson90481622012-03-21 16:34:12 -0700216}
217
Andy Whitcrofte7c4b0b2008-07-23 21:27:26 -0700218/*
Andy Whitcroft96822902008-07-23 21:27:29 -0700219 * Region tracking -- allows tracking of reservations and instantiated pages
220 * across the pages in a mapping.
Andy Whitcroft84afd992008-07-23 21:27:32 -0700221 *
Mike Kravetz1dd308a2015-06-24 16:57:52 -0700222 * The region data structures are embedded into a resv_map and protected
223 * by a resv_map's lock. The set of regions within the resv_map represent
224 * reservations for huge pages, or huge pages that have already been
225 * instantiated within the map. The from and to elements are huge page
226 * indicies into the associated mapping. from indicates the starting index
227 * of the region. to represents the first index past the end of the region.
228 *
229 * For example, a file region structure with from == 0 and to == 4 represents
230 * four huge pages in a mapping. It is important to note that the to element
231 * represents the first element past the end of the region. This is used in
232 * arithmetic as 4(to) - 0(from) = 4 huge pages in the region.
233 *
234 * Interval notation of the form [from, to) will be used to indicate that
235 * the endpoint from is inclusive and to is exclusive.
Andy Whitcroft96822902008-07-23 21:27:29 -0700236 */
237struct file_region {
238 struct list_head link;
239 long from;
240 long to;
241};
242
Mike Kravetz1dd308a2015-06-24 16:57:52 -0700243/*
244 * Add the huge page range represented by [f, t) to the reserve
Mike Kravetz5e911372015-09-08 15:01:28 -0700245 * map. In the normal case, existing regions will be expanded
246 * to accommodate the specified range. Sufficient regions should
247 * exist for expansion due to the previous call to region_chg
248 * with the same range. However, it is possible that region_del
249 * could have been called after region_chg and modifed the map
250 * in such a way that no region exists to be expanded. In this
251 * case, pull a region descriptor from the cache associated with
252 * the map and use that for the new range.
Mike Kravetzcf3ad202015-06-24 16:57:55 -0700253 *
254 * Return the number of new huge pages added to the map. This
255 * number is greater than or equal to zero.
Mike Kravetz1dd308a2015-06-24 16:57:52 -0700256 */
Joonsoo Kim1406ec92014-04-03 14:47:26 -0700257static long region_add(struct resv_map *resv, long f, long t)
Andy Whitcroft96822902008-07-23 21:27:29 -0700258{
Joonsoo Kim1406ec92014-04-03 14:47:26 -0700259 struct list_head *head = &resv->regions;
Andy Whitcroft96822902008-07-23 21:27:29 -0700260 struct file_region *rg, *nrg, *trg;
Mike Kravetzcf3ad202015-06-24 16:57:55 -0700261 long add = 0;
Andy Whitcroft96822902008-07-23 21:27:29 -0700262
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700263 spin_lock(&resv->lock);
Andy Whitcroft96822902008-07-23 21:27:29 -0700264 /* Locate the region we are either in or before. */
265 list_for_each_entry(rg, head, link)
266 if (f <= rg->to)
267 break;
268
Mike Kravetz5e911372015-09-08 15:01:28 -0700269 /*
270 * If no region exists which can be expanded to include the
271 * specified range, the list must have been modified by an
272 * interleving call to region_del(). Pull a region descriptor
273 * from the cache and use it for this range.
274 */
275 if (&rg->link == head || t < rg->from) {
276 VM_BUG_ON(resv->region_cache_count <= 0);
277
278 resv->region_cache_count--;
279 nrg = list_first_entry(&resv->region_cache, struct file_region,
280 link);
281 list_del(&nrg->link);
282
283 nrg->from = f;
284 nrg->to = t;
285 list_add(&nrg->link, rg->link.prev);
286
287 add += t - f;
288 goto out_locked;
289 }
290
Andy Whitcroft96822902008-07-23 21:27:29 -0700291 /* Round our left edge to the current segment if it encloses us. */
292 if (f > rg->from)
293 f = rg->from;
294
295 /* Check for and consume any regions we now overlap with. */
296 nrg = rg;
297 list_for_each_entry_safe(rg, trg, rg->link.prev, link) {
298 if (&rg->link == head)
299 break;
300 if (rg->from > t)
301 break;
302
303 /* If this area reaches higher then extend our area to
304 * include it completely. If this is not the first area
305 * which we intend to reuse, free it. */
306 if (rg->to > t)
307 t = rg->to;
308 if (rg != nrg) {
Mike Kravetzcf3ad202015-06-24 16:57:55 -0700309 /* Decrement return value by the deleted range.
310 * Another range will span this area so that by
311 * end of routine add will be >= zero
312 */
313 add -= (rg->to - rg->from);
Andy Whitcroft96822902008-07-23 21:27:29 -0700314 list_del(&rg->link);
315 kfree(rg);
316 }
317 }
Mike Kravetzcf3ad202015-06-24 16:57:55 -0700318
319 add += (nrg->from - f); /* Added to beginning of region */
Andy Whitcroft96822902008-07-23 21:27:29 -0700320 nrg->from = f;
Mike Kravetzcf3ad202015-06-24 16:57:55 -0700321 add += t - nrg->to; /* Added to end of region */
Andy Whitcroft96822902008-07-23 21:27:29 -0700322 nrg->to = t;
Mike Kravetzcf3ad202015-06-24 16:57:55 -0700323
Mike Kravetz5e911372015-09-08 15:01:28 -0700324out_locked:
325 resv->adds_in_progress--;
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700326 spin_unlock(&resv->lock);
Mike Kravetzcf3ad202015-06-24 16:57:55 -0700327 VM_BUG_ON(add < 0);
328 return add;
Andy Whitcroft96822902008-07-23 21:27:29 -0700329}
330
Mike Kravetz1dd308a2015-06-24 16:57:52 -0700331/*
332 * Examine the existing reserve map and determine how many
333 * huge pages in the specified range [f, t) are NOT currently
334 * represented. This routine is called before a subsequent
335 * call to region_add that will actually modify the reserve
336 * map to add the specified range [f, t). region_chg does
337 * not change the number of huge pages represented by the
338 * map. However, if the existing regions in the map can not
339 * be expanded to represent the new range, a new file_region
340 * structure is added to the map as a placeholder. This is
341 * so that the subsequent region_add call will have all the
342 * regions it needs and will not fail.
343 *
Mike Kravetz5e911372015-09-08 15:01:28 -0700344 * Upon entry, region_chg will also examine the cache of region descriptors
345 * associated with the map. If there are not enough descriptors cached, one
346 * will be allocated for the in progress add operation.
347 *
348 * Returns the number of huge pages that need to be added to the existing
349 * reservation map for the range [f, t). This number is greater or equal to
350 * zero. -ENOMEM is returned if a new file_region structure or cache entry
351 * is needed and can not be allocated.
Mike Kravetz1dd308a2015-06-24 16:57:52 -0700352 */
Joonsoo Kim1406ec92014-04-03 14:47:26 -0700353static long region_chg(struct resv_map *resv, long f, long t)
Andy Whitcroft96822902008-07-23 21:27:29 -0700354{
Joonsoo Kim1406ec92014-04-03 14:47:26 -0700355 struct list_head *head = &resv->regions;
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700356 struct file_region *rg, *nrg = NULL;
Andy Whitcroft96822902008-07-23 21:27:29 -0700357 long chg = 0;
358
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700359retry:
360 spin_lock(&resv->lock);
Mike Kravetz5e911372015-09-08 15:01:28 -0700361retry_locked:
362 resv->adds_in_progress++;
363
364 /*
365 * Check for sufficient descriptors in the cache to accommodate
366 * the number of in progress add operations.
367 */
368 if (resv->adds_in_progress > resv->region_cache_count) {
369 struct file_region *trg;
370
371 VM_BUG_ON(resv->adds_in_progress - resv->region_cache_count > 1);
372 /* Must drop lock to allocate a new descriptor. */
373 resv->adds_in_progress--;
374 spin_unlock(&resv->lock);
375
376 trg = kmalloc(sizeof(*trg), GFP_KERNEL);
Mike Kravetzdbe409e2015-12-11 13:40:52 -0800377 if (!trg) {
378 kfree(nrg);
Mike Kravetz5e911372015-09-08 15:01:28 -0700379 return -ENOMEM;
Mike Kravetzdbe409e2015-12-11 13:40:52 -0800380 }
Mike Kravetz5e911372015-09-08 15:01:28 -0700381
382 spin_lock(&resv->lock);
383 list_add(&trg->link, &resv->region_cache);
384 resv->region_cache_count++;
385 goto retry_locked;
386 }
387
Andy Whitcroft96822902008-07-23 21:27:29 -0700388 /* Locate the region we are before or in. */
389 list_for_each_entry(rg, head, link)
390 if (f <= rg->to)
391 break;
392
393 /* If we are below the current region then a new region is required.
394 * Subtle, allocate a new region at the position but make it zero
395 * size such that we can guarantee to record the reservation. */
396 if (&rg->link == head || t < rg->from) {
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700397 if (!nrg) {
Mike Kravetz5e911372015-09-08 15:01:28 -0700398 resv->adds_in_progress--;
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700399 spin_unlock(&resv->lock);
400 nrg = kmalloc(sizeof(*nrg), GFP_KERNEL);
401 if (!nrg)
402 return -ENOMEM;
Andy Whitcroft96822902008-07-23 21:27:29 -0700403
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700404 nrg->from = f;
405 nrg->to = f;
406 INIT_LIST_HEAD(&nrg->link);
407 goto retry;
408 }
409
410 list_add(&nrg->link, rg->link.prev);
411 chg = t - f;
412 goto out_nrg;
Andy Whitcroft96822902008-07-23 21:27:29 -0700413 }
414
415 /* Round our left edge to the current segment if it encloses us. */
416 if (f > rg->from)
417 f = rg->from;
418 chg = t - f;
419
420 /* Check for and consume any regions we now overlap with. */
421 list_for_each_entry(rg, rg->link.prev, link) {
422 if (&rg->link == head)
423 break;
424 if (rg->from > t)
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700425 goto out;
Andy Whitcroft96822902008-07-23 21:27:29 -0700426
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300427 /* We overlap with this area, if it extends further than
Andy Whitcroft96822902008-07-23 21:27:29 -0700428 * us then we must extend ourselves. Account for its
429 * existing reservation. */
430 if (rg->to > t) {
431 chg += rg->to - t;
432 t = rg->to;
433 }
434 chg -= rg->to - rg->from;
435 }
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700436
437out:
438 spin_unlock(&resv->lock);
439 /* We already know we raced and no longer need the new region */
440 kfree(nrg);
441 return chg;
442out_nrg:
443 spin_unlock(&resv->lock);
Andy Whitcroft96822902008-07-23 21:27:29 -0700444 return chg;
445}
446
Mike Kravetz1dd308a2015-06-24 16:57:52 -0700447/*
Mike Kravetz5e911372015-09-08 15:01:28 -0700448 * Abort the in progress add operation. The adds_in_progress field
449 * of the resv_map keeps track of the operations in progress between
450 * calls to region_chg and region_add. Operations are sometimes
451 * aborted after the call to region_chg. In such cases, region_abort
452 * is called to decrement the adds_in_progress counter.
453 *
454 * NOTE: The range arguments [f, t) are not needed or used in this
455 * routine. They are kept to make reading the calling code easier as
456 * arguments will match the associated region_chg call.
457 */
458static void region_abort(struct resv_map *resv, long f, long t)
459{
460 spin_lock(&resv->lock);
461 VM_BUG_ON(!resv->region_cache_count);
462 resv->adds_in_progress--;
463 spin_unlock(&resv->lock);
464}
465
466/*
Mike Kravetzfeba16e2015-09-08 15:01:31 -0700467 * Delete the specified range [f, t) from the reserve map. If the
468 * t parameter is LONG_MAX, this indicates that ALL regions after f
469 * should be deleted. Locate the regions which intersect [f, t)
470 * and either trim, delete or split the existing regions.
471 *
472 * Returns the number of huge pages deleted from the reserve map.
473 * In the normal case, the return value is zero or more. In the
474 * case where a region must be split, a new region descriptor must
475 * be allocated. If the allocation fails, -ENOMEM will be returned.
476 * NOTE: If the parameter t == LONG_MAX, then we will never split
477 * a region and possibly return -ENOMEM. Callers specifying
478 * t == LONG_MAX do not need to check for -ENOMEM error.
Mike Kravetz1dd308a2015-06-24 16:57:52 -0700479 */
Mike Kravetzfeba16e2015-09-08 15:01:31 -0700480static long region_del(struct resv_map *resv, long f, long t)
Andy Whitcroft96822902008-07-23 21:27:29 -0700481{
Joonsoo Kim1406ec92014-04-03 14:47:26 -0700482 struct list_head *head = &resv->regions;
Andy Whitcroft96822902008-07-23 21:27:29 -0700483 struct file_region *rg, *trg;
Mike Kravetzfeba16e2015-09-08 15:01:31 -0700484 struct file_region *nrg = NULL;
485 long del = 0;
Andy Whitcroft96822902008-07-23 21:27:29 -0700486
Mike Kravetzfeba16e2015-09-08 15:01:31 -0700487retry:
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700488 spin_lock(&resv->lock);
Mike Kravetzfeba16e2015-09-08 15:01:31 -0700489 list_for_each_entry_safe(rg, trg, head, link) {
Mike Kravetzdbe409e2015-12-11 13:40:52 -0800490 /*
491 * Skip regions before the range to be deleted. file_region
492 * ranges are normally of the form [from, to). However, there
493 * may be a "placeholder" entry in the map which is of the form
494 * (from, to) with from == to. Check for placeholder entries
495 * at the beginning of the range to be deleted.
496 */
497 if (rg->to <= f && (rg->to != rg->from || rg->to != f))
Mike Kravetzfeba16e2015-09-08 15:01:31 -0700498 continue;
Mike Kravetzdbe409e2015-12-11 13:40:52 -0800499
Mike Kravetzfeba16e2015-09-08 15:01:31 -0700500 if (rg->from >= t)
Andy Whitcroft96822902008-07-23 21:27:29 -0700501 break;
Andy Whitcroft96822902008-07-23 21:27:29 -0700502
Mike Kravetzfeba16e2015-09-08 15:01:31 -0700503 if (f > rg->from && t < rg->to) { /* Must split region */
504 /*
505 * Check for an entry in the cache before dropping
506 * lock and attempting allocation.
507 */
508 if (!nrg &&
509 resv->region_cache_count > resv->adds_in_progress) {
510 nrg = list_first_entry(&resv->region_cache,
511 struct file_region,
512 link);
513 list_del(&nrg->link);
514 resv->region_cache_count--;
515 }
516
517 if (!nrg) {
518 spin_unlock(&resv->lock);
519 nrg = kmalloc(sizeof(*nrg), GFP_KERNEL);
520 if (!nrg)
521 return -ENOMEM;
522 goto retry;
523 }
524
525 del += t - f;
526
527 /* New entry for end of split region */
528 nrg->from = t;
529 nrg->to = rg->to;
530 INIT_LIST_HEAD(&nrg->link);
531
532 /* Original entry is trimmed */
533 rg->to = f;
534
535 list_add(&nrg->link, &rg->link);
536 nrg = NULL;
537 break;
538 }
539
540 if (f <= rg->from && t >= rg->to) { /* Remove entire region */
541 del += rg->to - rg->from;
542 list_del(&rg->link);
543 kfree(rg);
544 continue;
545 }
546
547 if (f <= rg->from) { /* Trim beginning of region */
548 del += t - rg->from;
549 rg->from = t;
550 } else { /* Trim end of region */
551 del += rg->to - f;
552 rg->to = f;
553 }
Andy Whitcroft96822902008-07-23 21:27:29 -0700554 }
555
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700556 spin_unlock(&resv->lock);
Mike Kravetzfeba16e2015-09-08 15:01:31 -0700557 kfree(nrg);
558 return del;
Andy Whitcroft96822902008-07-23 21:27:29 -0700559}
560
Mike Kravetz1dd308a2015-06-24 16:57:52 -0700561/*
Mike Kravetzb5cec282015-09-08 15:01:41 -0700562 * A rare out of memory error was encountered which prevented removal of
563 * the reserve map region for a page. The huge page itself was free'ed
564 * and removed from the page cache. This routine will adjust the subpool
565 * usage count, and the global reserve count if needed. By incrementing
566 * these counts, the reserve map entry which could not be deleted will
567 * appear as a "reserved" entry instead of simply dangling with incorrect
568 * counts.
569 */
570void hugetlb_fix_reserve_counts(struct inode *inode, bool restore_reserve)
571{
572 struct hugepage_subpool *spool = subpool_inode(inode);
573 long rsv_adjust;
574
575 rsv_adjust = hugepage_subpool_get_pages(spool, 1);
576 if (restore_reserve && rsv_adjust) {
577 struct hstate *h = hstate_inode(inode);
578
579 hugetlb_acct_memory(h, 1);
580 }
581}
582
583/*
Mike Kravetz1dd308a2015-06-24 16:57:52 -0700584 * Count and return the number of huge pages in the reserve map
585 * that intersect with the range [f, t).
586 */
Joonsoo Kim1406ec92014-04-03 14:47:26 -0700587static long region_count(struct resv_map *resv, long f, long t)
Andy Whitcroft84afd992008-07-23 21:27:32 -0700588{
Joonsoo Kim1406ec92014-04-03 14:47:26 -0700589 struct list_head *head = &resv->regions;
Andy Whitcroft84afd992008-07-23 21:27:32 -0700590 struct file_region *rg;
591 long chg = 0;
592
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700593 spin_lock(&resv->lock);
Andy Whitcroft84afd992008-07-23 21:27:32 -0700594 /* Locate each segment we overlap with, and count that overlap. */
595 list_for_each_entry(rg, head, link) {
Wang Sheng-Huif2135a42012-05-29 15:06:17 -0700596 long seg_from;
597 long seg_to;
Andy Whitcroft84afd992008-07-23 21:27:32 -0700598
599 if (rg->to <= f)
600 continue;
601 if (rg->from >= t)
602 break;
603
604 seg_from = max(rg->from, f);
605 seg_to = min(rg->to, t);
606
607 chg += seg_to - seg_from;
608 }
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700609 spin_unlock(&resv->lock);
Andy Whitcroft84afd992008-07-23 21:27:32 -0700610
611 return chg;
612}
613
Andy Whitcroft96822902008-07-23 21:27:29 -0700614/*
Andy Whitcrofte7c4b0b2008-07-23 21:27:26 -0700615 * Convert the address within this vma to the page offset within
Andy Whitcrofte7c4b0b2008-07-23 21:27:26 -0700616 * the mapping, in pagecache page units; huge pages here.
617 */
Andi Kleena5516432008-07-23 21:27:41 -0700618static pgoff_t vma_hugecache_offset(struct hstate *h,
619 struct vm_area_struct *vma, unsigned long address)
Andy Whitcrofte7c4b0b2008-07-23 21:27:26 -0700620{
Andi Kleena5516432008-07-23 21:27:41 -0700621 return ((address - vma->vm_start) >> huge_page_shift(h)) +
622 (vma->vm_pgoff >> huge_page_order(h));
Andy Whitcrofte7c4b0b2008-07-23 21:27:26 -0700623}
624
Naoya Horiguchi0fe6e202010-05-28 09:29:16 +0900625pgoff_t linear_hugepage_index(struct vm_area_struct *vma,
626 unsigned long address)
627{
628 return vma_hugecache_offset(hstate_vma(vma), vma, address);
629}
Dan Williamsdee41072016-05-14 12:20:44 -0700630EXPORT_SYMBOL_GPL(linear_hugepage_index);
Naoya Horiguchi0fe6e202010-05-28 09:29:16 +0900631
Andy Whitcroft84afd992008-07-23 21:27:32 -0700632/*
Mel Gorman08fba692009-01-06 14:38:53 -0800633 * Return the size of the pages allocated when backing a VMA. In the majority
634 * cases this will be same size as used by the page table entries.
635 */
636unsigned long vma_kernel_pagesize(struct vm_area_struct *vma)
637{
638 struct hstate *hstate;
639
640 if (!is_vm_hugetlb_page(vma))
641 return PAGE_SIZE;
642
643 hstate = hstate_vma(vma);
644
Wanpeng Li2415cf12013-07-03 15:02:43 -0700645 return 1UL << huge_page_shift(hstate);
Mel Gorman08fba692009-01-06 14:38:53 -0800646}
Joerg Roedelf340ca02009-06-19 15:16:22 +0200647EXPORT_SYMBOL_GPL(vma_kernel_pagesize);
Mel Gorman08fba692009-01-06 14:38:53 -0800648
649/*
Mel Gorman33402892009-01-06 14:38:54 -0800650 * Return the page size being used by the MMU to back a VMA. In the majority
651 * of cases, the page size used by the kernel matches the MMU size. On
652 * architectures where it differs, an architecture-specific version of this
653 * function is required.
654 */
655#ifndef vma_mmu_pagesize
656unsigned long vma_mmu_pagesize(struct vm_area_struct *vma)
657{
658 return vma_kernel_pagesize(vma);
659}
660#endif
661
662/*
Andy Whitcroft84afd992008-07-23 21:27:32 -0700663 * Flags for MAP_PRIVATE reservations. These are stored in the bottom
664 * bits of the reservation map pointer, which are always clear due to
665 * alignment.
666 */
667#define HPAGE_RESV_OWNER (1UL << 0)
668#define HPAGE_RESV_UNMAPPED (1UL << 1)
Mel Gorman04f2cbe2008-07-23 21:27:25 -0700669#define HPAGE_RESV_MASK (HPAGE_RESV_OWNER | HPAGE_RESV_UNMAPPED)
Andy Whitcroft84afd992008-07-23 21:27:32 -0700670
Mel Gormana1e78772008-07-23 21:27:23 -0700671/*
672 * These helpers are used to track how many pages are reserved for
673 * faults in a MAP_PRIVATE mapping. Only the process that called mmap()
674 * is guaranteed to have their future faults succeed.
675 *
676 * With the exception of reset_vma_resv_huge_pages() which is called at fork(),
677 * the reserve counters are updated with the hugetlb_lock held. It is safe
678 * to reset the VMA at fork() time as it is not in use yet and there is no
679 * chance of the global counters getting corrupted as a result of the values.
Andy Whitcroft84afd992008-07-23 21:27:32 -0700680 *
681 * The private mapping reservation is represented in a subtly different
682 * manner to a shared mapping. A shared mapping has a region map associated
683 * with the underlying file, this region map represents the backing file
684 * pages which have ever had a reservation assigned which this persists even
685 * after the page is instantiated. A private mapping has a region map
686 * associated with the original mmap which is attached to all VMAs which
687 * reference it, this region map represents those offsets which have consumed
688 * reservation ie. where pages have been instantiated.
Mel Gormana1e78772008-07-23 21:27:23 -0700689 */
Andy Whitcrofte7c4b0b2008-07-23 21:27:26 -0700690static unsigned long get_vma_private_data(struct vm_area_struct *vma)
691{
692 return (unsigned long)vma->vm_private_data;
693}
694
695static void set_vma_private_data(struct vm_area_struct *vma,
696 unsigned long value)
697{
698 vma->vm_private_data = (void *)value;
699}
700
Joonsoo Kim9119a412014-04-03 14:47:25 -0700701struct resv_map *resv_map_alloc(void)
Andy Whitcroft84afd992008-07-23 21:27:32 -0700702{
703 struct resv_map *resv_map = kmalloc(sizeof(*resv_map), GFP_KERNEL);
Mike Kravetz5e911372015-09-08 15:01:28 -0700704 struct file_region *rg = kmalloc(sizeof(*rg), GFP_KERNEL);
705
706 if (!resv_map || !rg) {
707 kfree(resv_map);
708 kfree(rg);
Andy Whitcroft84afd992008-07-23 21:27:32 -0700709 return NULL;
Mike Kravetz5e911372015-09-08 15:01:28 -0700710 }
Andy Whitcroft84afd992008-07-23 21:27:32 -0700711
712 kref_init(&resv_map->refs);
Davidlohr Bueso7b24d862014-04-03 14:47:27 -0700713 spin_lock_init(&resv_map->lock);
Andy Whitcroft84afd992008-07-23 21:27:32 -0700714 INIT_LIST_HEAD(&resv_map->regions);
715
Mike Kravetz5e911372015-09-08 15:01:28 -0700716 resv_map->adds_in_progress = 0;
717
718 INIT_LIST_HEAD(&resv_map->region_cache);
719 list_add(&rg->link, &resv_map->region_cache);
720 resv_map->region_cache_count = 1;
721
Andy Whitcroft84afd992008-07-23 21:27:32 -0700722 return resv_map;
723}
724
Joonsoo Kim9119a412014-04-03 14:47:25 -0700725void resv_map_release(struct kref *ref)
Andy Whitcroft84afd992008-07-23 21:27:32 -0700726{
727 struct resv_map *resv_map = container_of(ref, struct resv_map, refs);
Mike Kravetz5e911372015-09-08 15:01:28 -0700728 struct list_head *head = &resv_map->region_cache;
729 struct file_region *rg, *trg;
Andy Whitcroft84afd992008-07-23 21:27:32 -0700730
731 /* Clear out any active regions before we release the map. */
Mike Kravetzfeba16e2015-09-08 15:01:31 -0700732 region_del(resv_map, 0, LONG_MAX);
Mike Kravetz5e911372015-09-08 15:01:28 -0700733
734 /* ... and any entries left in the cache */
735 list_for_each_entry_safe(rg, trg, head, link) {
736 list_del(&rg->link);
737 kfree(rg);
738 }
739
740 VM_BUG_ON(resv_map->adds_in_progress);
741
Andy Whitcroft84afd992008-07-23 21:27:32 -0700742 kfree(resv_map);
743}
744
Joonsoo Kim4e35f482014-04-03 14:47:30 -0700745static inline struct resv_map *inode_resv_map(struct inode *inode)
746{
747 return inode->i_mapping->private_data;
748}
749
Andy Whitcroft84afd992008-07-23 21:27:32 -0700750static struct resv_map *vma_resv_map(struct vm_area_struct *vma)
Mel Gormana1e78772008-07-23 21:27:23 -0700751{
Sasha Levin81d1b092014-10-09 15:28:10 -0700752 VM_BUG_ON_VMA(!is_vm_hugetlb_page(vma), vma);
Joonsoo Kim4e35f482014-04-03 14:47:30 -0700753 if (vma->vm_flags & VM_MAYSHARE) {
754 struct address_space *mapping = vma->vm_file->f_mapping;
755 struct inode *inode = mapping->host;
756
757 return inode_resv_map(inode);
758
759 } else {
Andy Whitcroft84afd992008-07-23 21:27:32 -0700760 return (struct resv_map *)(get_vma_private_data(vma) &
761 ~HPAGE_RESV_MASK);
Joonsoo Kim4e35f482014-04-03 14:47:30 -0700762 }
Mel Gormana1e78772008-07-23 21:27:23 -0700763}
764
Andy Whitcroft84afd992008-07-23 21:27:32 -0700765static void set_vma_resv_map(struct vm_area_struct *vma, struct resv_map *map)
Mel Gormana1e78772008-07-23 21:27:23 -0700766{
Sasha Levin81d1b092014-10-09 15:28:10 -0700767 VM_BUG_ON_VMA(!is_vm_hugetlb_page(vma), vma);
768 VM_BUG_ON_VMA(vma->vm_flags & VM_MAYSHARE, vma);
Mel Gormana1e78772008-07-23 21:27:23 -0700769
Andy Whitcroft84afd992008-07-23 21:27:32 -0700770 set_vma_private_data(vma, (get_vma_private_data(vma) &
771 HPAGE_RESV_MASK) | (unsigned long)map);
Mel Gorman04f2cbe2008-07-23 21:27:25 -0700772}
773
774static void set_vma_resv_flags(struct vm_area_struct *vma, unsigned long flags)
775{
Sasha Levin81d1b092014-10-09 15:28:10 -0700776 VM_BUG_ON_VMA(!is_vm_hugetlb_page(vma), vma);
777 VM_BUG_ON_VMA(vma->vm_flags & VM_MAYSHARE, vma);
Andy Whitcrofte7c4b0b2008-07-23 21:27:26 -0700778
779 set_vma_private_data(vma, get_vma_private_data(vma) | flags);
Mel Gorman04f2cbe2008-07-23 21:27:25 -0700780}
781
782static int is_vma_resv_set(struct vm_area_struct *vma, unsigned long flag)
783{
Sasha Levin81d1b092014-10-09 15:28:10 -0700784 VM_BUG_ON_VMA(!is_vm_hugetlb_page(vma), vma);
Andy Whitcrofte7c4b0b2008-07-23 21:27:26 -0700785
786 return (get_vma_private_data(vma) & flag) != 0;
Mel Gormana1e78772008-07-23 21:27:23 -0700787}
788
Mel Gorman04f2cbe2008-07-23 21:27:25 -0700789/* Reset counters to 0 and clear all HPAGE_RESV_* flags */
Mel Gormana1e78772008-07-23 21:27:23 -0700790void reset_vma_resv_huge_pages(struct vm_area_struct *vma)
791{
Sasha Levin81d1b092014-10-09 15:28:10 -0700792 VM_BUG_ON_VMA(!is_vm_hugetlb_page(vma), vma);
Mel Gormanf83a2752009-05-28 14:34:40 -0700793 if (!(vma->vm_flags & VM_MAYSHARE))
Mel Gormana1e78772008-07-23 21:27:23 -0700794 vma->vm_private_data = (void *)0;
795}
796
797/* Returns true if the VMA has associated reserve pages */
Nicholas Krause559ec2f2015-09-04 15:48:27 -0700798static bool vma_has_reserves(struct vm_area_struct *vma, long chg)
Mel Gormana1e78772008-07-23 21:27:23 -0700799{
Joonsoo Kimaf0ed732013-09-11 14:21:18 -0700800 if (vma->vm_flags & VM_NORESERVE) {
801 /*
802 * This address is already reserved by other process(chg == 0),
803 * so, we should decrement reserved count. Without decrementing,
804 * reserve count remains after releasing inode, because this
805 * allocated page will go into page cache and is regarded as
806 * coming from reserved pool in releasing step. Currently, we
807 * don't have any other solution to deal with this situation
808 * properly, so add work-around here.
809 */
810 if (vma->vm_flags & VM_MAYSHARE && chg == 0)
Nicholas Krause559ec2f2015-09-04 15:48:27 -0700811 return true;
Joonsoo Kimaf0ed732013-09-11 14:21:18 -0700812 else
Nicholas Krause559ec2f2015-09-04 15:48:27 -0700813 return false;
Joonsoo Kimaf0ed732013-09-11 14:21:18 -0700814 }
Joonsoo Kima63884e2013-09-11 14:21:07 -0700815
816 /* Shared mappings always use reserves */
Mike Kravetz1fb1b0e2015-09-08 15:01:44 -0700817 if (vma->vm_flags & VM_MAYSHARE) {
818 /*
819 * We know VM_NORESERVE is not set. Therefore, there SHOULD
820 * be a region map for all pages. The only situation where
821 * there is no region map is if a hole was punched via
822 * fallocate. In this case, there really are no reverves to
823 * use. This situation is indicated if chg != 0.
824 */
825 if (chg)
826 return false;
827 else
828 return true;
829 }
Joonsoo Kima63884e2013-09-11 14:21:07 -0700830
831 /*
832 * Only the process that called mmap() has reserves for
833 * private mappings.
834 */
Mike Kravetz67961f92016-06-08 15:33:42 -0700835 if (is_vma_resv_set(vma, HPAGE_RESV_OWNER)) {
836 /*
837 * Like the shared case above, a hole punch or truncate
838 * could have been performed on the private mapping.
839 * Examine the value of chg to determine if reserves
840 * actually exist or were previously consumed.
841 * Very Subtle - The value of chg comes from a previous
842 * call to vma_needs_reserves(). The reserve map for
843 * private mappings has different (opposite) semantics
844 * than that of shared mappings. vma_needs_reserves()
845 * has already taken this difference in semantics into
846 * account. Therefore, the meaning of chg is the same
847 * as in the shared case above. Code could easily be
848 * combined, but keeping it separate draws attention to
849 * subtle differences.
850 */
851 if (chg)
852 return false;
853 else
854 return true;
855 }
Joonsoo Kima63884e2013-09-11 14:21:07 -0700856
Nicholas Krause559ec2f2015-09-04 15:48:27 -0700857 return false;
Mel Gormana1e78772008-07-23 21:27:23 -0700858}
859
Andi Kleena5516432008-07-23 21:27:41 -0700860static void enqueue_huge_page(struct hstate *h, struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861{
862 int nid = page_to_nid(page);
Aneesh Kumar K.V0edaecf2012-07-31 16:42:07 -0700863 list_move(&page->lru, &h->hugepage_freelists[nid]);
Andi Kleena5516432008-07-23 21:27:41 -0700864 h->free_huge_pages++;
865 h->free_huge_pages_node[nid]++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866}
867
Naoya Horiguchibf50bab2010-09-08 10:19:33 +0900868static struct page *dequeue_huge_page_node(struct hstate *h, int nid)
869{
870 struct page *page;
871
Naoya Horiguchic8721bb2013-09-11 14:22:09 -0700872 list_for_each_entry(page, &h->hugepage_freelists[nid], lru)
873 if (!is_migrate_isolate_page(page))
874 break;
875 /*
876 * if 'non-isolated free hugepage' not found on the list,
877 * the allocation fails.
878 */
879 if (&h->hugepage_freelists[nid] == &page->lru)
Naoya Horiguchibf50bab2010-09-08 10:19:33 +0900880 return NULL;
Aneesh Kumar K.V0edaecf2012-07-31 16:42:07 -0700881 list_move(&page->lru, &h->hugepage_activelist);
Naoya Horiguchia9869b82010-09-08 10:19:37 +0900882 set_page_refcounted(page);
Naoya Horiguchibf50bab2010-09-08 10:19:33 +0900883 h->free_huge_pages--;
884 h->free_huge_pages_node[nid]--;
885 return page;
886}
887
Naoya Horiguchi86cdb462013-09-11 14:22:13 -0700888/* Movability of hugepages depends on migration support. */
889static inline gfp_t htlb_alloc_mask(struct hstate *h)
890{
Naoya Horiguchi100873d2014-06-04 16:10:56 -0700891 if (hugepages_treat_as_movable || hugepage_migration_supported(h))
Naoya Horiguchi86cdb462013-09-11 14:22:13 -0700892 return GFP_HIGHUSER_MOVABLE;
893 else
894 return GFP_HIGHUSER;
895}
896
Andi Kleena5516432008-07-23 21:27:41 -0700897static struct page *dequeue_huge_page_vma(struct hstate *h,
898 struct vm_area_struct *vma,
Joonsoo Kimaf0ed732013-09-11 14:21:18 -0700899 unsigned long address, int avoid_reserve,
900 long chg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901{
Konstantin Khlebnikovb1c12cb2012-04-25 16:01:46 -0700902 struct page *page = NULL;
Lee Schermerhorn480eccf2007-09-18 22:46:47 -0700903 struct mempolicy *mpol;
Mel Gorman19770b32008-04-28 02:12:18 -0700904 nodemask_t *nodemask;
Miao Xiec0ff7452010-05-24 14:32:08 -0700905 struct zonelist *zonelist;
Mel Gormandd1a2392008-04-28 02:12:17 -0700906 struct zone *zone;
907 struct zoneref *z;
Mel Gormancc9a6c82012-03-21 16:34:11 -0700908 unsigned int cpuset_mems_cookie;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
Mel Gormana1e78772008-07-23 21:27:23 -0700910 /*
911 * A child process with MAP_PRIVATE mappings created by their parent
912 * have no page reserves. This check ensures that reservations are
913 * not "stolen". The child may still get SIGKILLed
914 */
Joonsoo Kimaf0ed732013-09-11 14:21:18 -0700915 if (!vma_has_reserves(vma, chg) &&
Andi Kleena5516432008-07-23 21:27:41 -0700916 h->free_huge_pages - h->resv_huge_pages == 0)
Miao Xiec0ff7452010-05-24 14:32:08 -0700917 goto err;
Mel Gormana1e78772008-07-23 21:27:23 -0700918
Mel Gorman04f2cbe2008-07-23 21:27:25 -0700919 /* If reserves cannot be used, ensure enough pages are in the pool */
Andi Kleena5516432008-07-23 21:27:41 -0700920 if (avoid_reserve && h->free_huge_pages - h->resv_huge_pages == 0)
Justin P. Mattock6eab04a2011-04-08 19:49:08 -0700921 goto err;
Mel Gorman04f2cbe2008-07-23 21:27:25 -0700922
Joonsoo Kim9966c4b2013-09-11 14:20:50 -0700923retry_cpuset:
Mel Gormand26914d2014-04-03 14:47:24 -0700924 cpuset_mems_cookie = read_mems_allowed_begin();
Joonsoo Kim9966c4b2013-09-11 14:20:50 -0700925 zonelist = huge_zonelist(vma, address,
Naoya Horiguchi86cdb462013-09-11 14:22:13 -0700926 htlb_alloc_mask(h), &mpol, &nodemask);
Joonsoo Kim9966c4b2013-09-11 14:20:50 -0700927
Mel Gorman19770b32008-04-28 02:12:18 -0700928 for_each_zone_zonelist_nodemask(zone, z, zonelist,
929 MAX_NR_ZONES - 1, nodemask) {
Vladimir Davydov344736f2014-10-20 15:50:30 +0400930 if (cpuset_zone_allowed(zone, htlb_alloc_mask(h))) {
Naoya Horiguchibf50bab2010-09-08 10:19:33 +0900931 page = dequeue_huge_page_node(h, zone_to_nid(zone));
932 if (page) {
Joonsoo Kimaf0ed732013-09-11 14:21:18 -0700933 if (avoid_reserve)
934 break;
935 if (!vma_has_reserves(vma, chg))
936 break;
937
Joonsoo Kim07443a82013-09-11 14:21:58 -0700938 SetPagePrivate(page);
Joonsoo Kimaf0ed732013-09-11 14:21:18 -0700939 h->resv_huge_pages--;
Naoya Horiguchibf50bab2010-09-08 10:19:33 +0900940 break;
941 }
Andrew Morton3abf7af2007-07-19 01:49:08 -0700942 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 }
Mel Gormancc9a6c82012-03-21 16:34:11 -0700944
945 mpol_cond_put(mpol);
Mel Gormand26914d2014-04-03 14:47:24 -0700946 if (unlikely(!page && read_mems_allowed_retry(cpuset_mems_cookie)))
Mel Gormancc9a6c82012-03-21 16:34:11 -0700947 goto retry_cpuset;
948 return page;
949
Miao Xiec0ff7452010-05-24 14:32:08 -0700950err:
Mel Gormancc9a6c82012-03-21 16:34:11 -0700951 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952}
953
Luiz Capitulino1cac6f22014-06-04 16:07:11 -0700954/*
955 * common helper functions for hstate_next_node_to_{alloc|free}.
956 * We may have allocated or freed a huge page based on a different
957 * nodes_allowed previously, so h->next_node_to_{alloc|free} might
958 * be outside of *nodes_allowed. Ensure that we use an allowed
959 * node for alloc or free.
960 */
961static int next_node_allowed(int nid, nodemask_t *nodes_allowed)
962{
Andrew Morton0edaf862016-05-19 17:10:58 -0700963 nid = next_node_in(nid, *nodes_allowed);
Luiz Capitulino1cac6f22014-06-04 16:07:11 -0700964 VM_BUG_ON(nid >= MAX_NUMNODES);
965
966 return nid;
967}
968
969static int get_valid_node_allowed(int nid, nodemask_t *nodes_allowed)
970{
971 if (!node_isset(nid, *nodes_allowed))
972 nid = next_node_allowed(nid, nodes_allowed);
973 return nid;
974}
975
976/*
977 * returns the previously saved node ["this node"] from which to
978 * allocate a persistent huge page for the pool and advance the
979 * next node from which to allocate, handling wrap at end of node
980 * mask.
981 */
982static int hstate_next_node_to_alloc(struct hstate *h,
983 nodemask_t *nodes_allowed)
984{
985 int nid;
986
987 VM_BUG_ON(!nodes_allowed);
988
989 nid = get_valid_node_allowed(h->next_nid_to_alloc, nodes_allowed);
990 h->next_nid_to_alloc = next_node_allowed(nid, nodes_allowed);
991
992 return nid;
993}
994
995/*
996 * helper for free_pool_huge_page() - return the previously saved
997 * node ["this node"] from which to free a huge page. Advance the
998 * next node id whether or not we find a free huge page to free so
999 * that the next attempt to free addresses the next node.
1000 */
1001static int hstate_next_node_to_free(struct hstate *h, nodemask_t *nodes_allowed)
1002{
1003 int nid;
1004
1005 VM_BUG_ON(!nodes_allowed);
1006
1007 nid = get_valid_node_allowed(h->next_nid_to_free, nodes_allowed);
1008 h->next_nid_to_free = next_node_allowed(nid, nodes_allowed);
1009
1010 return nid;
1011}
1012
1013#define for_each_node_mask_to_alloc(hs, nr_nodes, node, mask) \
1014 for (nr_nodes = nodes_weight(*mask); \
1015 nr_nodes > 0 && \
1016 ((node = hstate_next_node_to_alloc(hs, mask)) || 1); \
1017 nr_nodes--)
1018
1019#define for_each_node_mask_to_free(hs, nr_nodes, node, mask) \
1020 for (nr_nodes = nodes_weight(*mask); \
1021 nr_nodes > 0 && \
1022 ((node = hstate_next_node_to_free(hs, mask)) || 1); \
1023 nr_nodes--)
1024
Vlastimil Babka080fe202016-02-05 15:36:41 -08001025#if defined(CONFIG_X86_64) && ((defined(CONFIG_MEMORY_ISOLATION) && defined(CONFIG_COMPACTION)) || defined(CONFIG_CMA))
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001026static void destroy_compound_gigantic_page(struct page *page,
Kirill A. Shutemovd00181b2015-11-06 16:29:57 -08001027 unsigned int order)
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001028{
1029 int i;
1030 int nr_pages = 1 << order;
1031 struct page *p = page + 1;
1032
1033 for (i = 1; i < nr_pages; i++, p = mem_map_next(p, page, i)) {
Kirill A. Shutemov1d798ca2015-11-06 16:29:54 -08001034 clear_compound_head(p);
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001035 set_page_refcounted(p);
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001036 }
1037
1038 set_compound_order(page, 0);
1039 __ClearPageHead(page);
1040}
1041
Kirill A. Shutemovd00181b2015-11-06 16:29:57 -08001042static void free_gigantic_page(struct page *page, unsigned int order)
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001043{
1044 free_contig_range(page_to_pfn(page), 1 << order);
1045}
1046
1047static int __alloc_gigantic_page(unsigned long start_pfn,
1048 unsigned long nr_pages)
1049{
1050 unsigned long end_pfn = start_pfn + nr_pages;
1051 return alloc_contig_range(start_pfn, end_pfn, MIGRATE_MOVABLE);
1052}
1053
Joonsoo Kimf44b2dda82016-05-19 17:12:03 -07001054static bool pfn_range_valid_gigantic(struct zone *z,
1055 unsigned long start_pfn, unsigned long nr_pages)
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001056{
1057 unsigned long i, end_pfn = start_pfn + nr_pages;
1058 struct page *page;
1059
1060 for (i = start_pfn; i < end_pfn; i++) {
1061 if (!pfn_valid(i))
1062 return false;
1063
1064 page = pfn_to_page(i);
1065
Joonsoo Kimf44b2dda82016-05-19 17:12:03 -07001066 if (page_zone(page) != z)
1067 return false;
1068
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001069 if (PageReserved(page))
1070 return false;
1071
1072 if (page_count(page) > 0)
1073 return false;
1074
1075 if (PageHuge(page))
1076 return false;
1077 }
1078
1079 return true;
1080}
1081
1082static bool zone_spans_last_pfn(const struct zone *zone,
1083 unsigned long start_pfn, unsigned long nr_pages)
1084{
1085 unsigned long last_pfn = start_pfn + nr_pages - 1;
1086 return zone_spans_pfn(zone, last_pfn);
1087}
1088
Kirill A. Shutemovd00181b2015-11-06 16:29:57 -08001089static struct page *alloc_gigantic_page(int nid, unsigned int order)
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001090{
1091 unsigned long nr_pages = 1 << order;
1092 unsigned long ret, pfn, flags;
1093 struct zone *z;
1094
1095 z = NODE_DATA(nid)->node_zones;
1096 for (; z - NODE_DATA(nid)->node_zones < MAX_NR_ZONES; z++) {
1097 spin_lock_irqsave(&z->lock, flags);
1098
1099 pfn = ALIGN(z->zone_start_pfn, nr_pages);
1100 while (zone_spans_last_pfn(z, pfn, nr_pages)) {
Joonsoo Kimf44b2dda82016-05-19 17:12:03 -07001101 if (pfn_range_valid_gigantic(z, pfn, nr_pages)) {
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001102 /*
1103 * We release the zone lock here because
1104 * alloc_contig_range() will also lock the zone
1105 * at some point. If there's an allocation
1106 * spinning on this lock, it may win the race
1107 * and cause alloc_contig_range() to fail...
1108 */
1109 spin_unlock_irqrestore(&z->lock, flags);
1110 ret = __alloc_gigantic_page(pfn, nr_pages);
1111 if (!ret)
1112 return pfn_to_page(pfn);
1113 spin_lock_irqsave(&z->lock, flags);
1114 }
1115 pfn += nr_pages;
1116 }
1117
1118 spin_unlock_irqrestore(&z->lock, flags);
1119 }
1120
1121 return NULL;
1122}
1123
1124static void prep_new_huge_page(struct hstate *h, struct page *page, int nid);
Kirill A. Shutemovd00181b2015-11-06 16:29:57 -08001125static void prep_compound_gigantic_page(struct page *page, unsigned int order);
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001126
1127static struct page *alloc_fresh_gigantic_page_node(struct hstate *h, int nid)
1128{
1129 struct page *page;
1130
1131 page = alloc_gigantic_page(nid, huge_page_order(h));
1132 if (page) {
1133 prep_compound_gigantic_page(page, huge_page_order(h));
1134 prep_new_huge_page(h, page, nid);
1135 }
1136
1137 return page;
1138}
1139
1140static int alloc_fresh_gigantic_page(struct hstate *h,
1141 nodemask_t *nodes_allowed)
1142{
1143 struct page *page = NULL;
1144 int nr_nodes, node;
1145
1146 for_each_node_mask_to_alloc(h, nr_nodes, node, nodes_allowed) {
1147 page = alloc_fresh_gigantic_page_node(h, node);
1148 if (page)
1149 return 1;
1150 }
1151
1152 return 0;
1153}
1154
1155static inline bool gigantic_page_supported(void) { return true; }
1156#else
1157static inline bool gigantic_page_supported(void) { return false; }
Kirill A. Shutemovd00181b2015-11-06 16:29:57 -08001158static inline void free_gigantic_page(struct page *page, unsigned int order) { }
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001159static inline void destroy_compound_gigantic_page(struct page *page,
Kirill A. Shutemovd00181b2015-11-06 16:29:57 -08001160 unsigned int order) { }
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001161static inline int alloc_fresh_gigantic_page(struct hstate *h,
1162 nodemask_t *nodes_allowed) { return 0; }
1163#endif
1164
Andi Kleena5516432008-07-23 21:27:41 -07001165static void update_and_free_page(struct hstate *h, struct page *page)
Adam Litke6af2acb2007-10-16 01:26:16 -07001166{
1167 int i;
Andi Kleena5516432008-07-23 21:27:41 -07001168
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001169 if (hstate_is_gigantic(h) && !gigantic_page_supported())
1170 return;
Andy Whitcroft18229df2008-11-06 12:53:27 -08001171
Andi Kleena5516432008-07-23 21:27:41 -07001172 h->nr_huge_pages--;
1173 h->nr_huge_pages_node[page_to_nid(page)]--;
1174 for (i = 0; i < pages_per_huge_page(h); i++) {
Chris Forbes32f84522011-07-25 17:12:14 -07001175 page[i].flags &= ~(1 << PG_locked | 1 << PG_error |
1176 1 << PG_referenced | 1 << PG_dirty |
Luiz Capitulinoa7407a22014-06-04 16:07:09 -07001177 1 << PG_active | 1 << PG_private |
1178 1 << PG_writeback);
Adam Litke6af2acb2007-10-16 01:26:16 -07001179 }
Sasha Levin309381fea2014-01-23 15:52:54 -08001180 VM_BUG_ON_PAGE(hugetlb_cgroup_from_page(page), page);
Kirill A. Shutemovf1e61552015-11-06 16:29:50 -08001181 set_compound_page_dtor(page, NULL_COMPOUND_DTOR);
Adam Litke6af2acb2007-10-16 01:26:16 -07001182 set_page_refcounted(page);
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001183 if (hstate_is_gigantic(h)) {
1184 destroy_compound_gigantic_page(page, huge_page_order(h));
1185 free_gigantic_page(page, huge_page_order(h));
1186 } else {
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001187 __free_pages(page, huge_page_order(h));
1188 }
Adam Litke6af2acb2007-10-16 01:26:16 -07001189}
1190
Andi Kleene5ff2152008-07-23 21:27:42 -07001191struct hstate *size_to_hstate(unsigned long size)
1192{
1193 struct hstate *h;
1194
1195 for_each_hstate(h) {
1196 if (huge_page_size(h) == size)
1197 return h;
1198 }
1199 return NULL;
1200}
1201
Naoya Horiguchibcc54222015-04-15 16:14:38 -07001202/*
1203 * Test to determine whether the hugepage is "active/in-use" (i.e. being linked
1204 * to hstate->hugepage_activelist.)
1205 *
1206 * This function can be called for tail pages, but never returns true for them.
1207 */
1208bool page_huge_active(struct page *page)
1209{
1210 VM_BUG_ON_PAGE(!PageHuge(page), page);
1211 return PageHead(page) && PagePrivate(&page[1]);
1212}
1213
1214/* never called for tail page */
1215static void set_page_huge_active(struct page *page)
1216{
1217 VM_BUG_ON_PAGE(!PageHeadHuge(page), page);
1218 SetPagePrivate(&page[1]);
1219}
1220
1221static void clear_page_huge_active(struct page *page)
1222{
1223 VM_BUG_ON_PAGE(!PageHeadHuge(page), page);
1224 ClearPagePrivate(&page[1]);
1225}
1226
Atsushi Kumagai8f1d26d2014-07-30 16:08:39 -07001227void free_huge_page(struct page *page)
David Gibson27a85ef2006-03-22 00:08:56 -08001228{
Andi Kleena5516432008-07-23 21:27:41 -07001229 /*
1230 * Can't pass hstate in here because it is called from the
1231 * compound page destructor.
1232 */
Andi Kleene5ff2152008-07-23 21:27:42 -07001233 struct hstate *h = page_hstate(page);
Adam Litke7893d1d2007-10-16 01:26:18 -07001234 int nid = page_to_nid(page);
David Gibson90481622012-03-21 16:34:12 -07001235 struct hugepage_subpool *spool =
1236 (struct hugepage_subpool *)page_private(page);
Joonsoo Kim07443a82013-09-11 14:21:58 -07001237 bool restore_reserve;
David Gibson27a85ef2006-03-22 00:08:56 -08001238
Andy Whitcrofte5df70a2008-02-23 15:23:32 -08001239 set_page_private(page, 0);
Mel Gorman23be7462010-04-23 13:17:56 -04001240 page->mapping = NULL;
Mike Kravetzb4330af2016-02-05 15:36:38 -08001241 VM_BUG_ON_PAGE(page_count(page), page);
1242 VM_BUG_ON_PAGE(page_mapcount(page), page);
Joonsoo Kim07443a82013-09-11 14:21:58 -07001243 restore_reserve = PagePrivate(page);
Joonsoo Kim16c794b2013-10-16 13:46:48 -07001244 ClearPagePrivate(page);
David Gibson27a85ef2006-03-22 00:08:56 -08001245
Mike Kravetz1c5ecae2015-04-15 16:13:39 -07001246 /*
1247 * A return code of zero implies that the subpool will be under its
1248 * minimum size if the reservation is not restored after page is free.
1249 * Therefore, force restore_reserve operation.
1250 */
1251 if (hugepage_subpool_put_pages(spool, 1) == 0)
1252 restore_reserve = true;
1253
David Gibson27a85ef2006-03-22 00:08:56 -08001254 spin_lock(&hugetlb_lock);
Naoya Horiguchibcc54222015-04-15 16:14:38 -07001255 clear_page_huge_active(page);
Aneesh Kumar K.V6d76dcf2012-07-31 16:42:18 -07001256 hugetlb_cgroup_uncharge_page(hstate_index(h),
1257 pages_per_huge_page(h), page);
Joonsoo Kim07443a82013-09-11 14:21:58 -07001258 if (restore_reserve)
1259 h->resv_huge_pages++;
1260
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07001261 if (h->surplus_huge_pages_node[nid]) {
Aneesh Kumar K.V0edaecf2012-07-31 16:42:07 -07001262 /* remove the page from active list */
1263 list_del(&page->lru);
Andi Kleena5516432008-07-23 21:27:41 -07001264 update_and_free_page(h, page);
1265 h->surplus_huge_pages--;
1266 h->surplus_huge_pages_node[nid]--;
Adam Litke7893d1d2007-10-16 01:26:18 -07001267 } else {
Will Deacon5d3a5512012-10-08 16:29:32 -07001268 arch_clear_hugepage_flags(page);
Andi Kleena5516432008-07-23 21:27:41 -07001269 enqueue_huge_page(h, page);
Adam Litke7893d1d2007-10-16 01:26:18 -07001270 }
David Gibson27a85ef2006-03-22 00:08:56 -08001271 spin_unlock(&hugetlb_lock);
1272}
1273
Andi Kleena5516432008-07-23 21:27:41 -07001274static void prep_new_huge_page(struct hstate *h, struct page *page, int nid)
Andi Kleenb7ba30c2008-07-23 21:27:40 -07001275{
Aneesh Kumar K.V0edaecf2012-07-31 16:42:07 -07001276 INIT_LIST_HEAD(&page->lru);
Kirill A. Shutemovf1e61552015-11-06 16:29:50 -08001277 set_compound_page_dtor(page, HUGETLB_PAGE_DTOR);
Andi Kleenb7ba30c2008-07-23 21:27:40 -07001278 spin_lock(&hugetlb_lock);
Aneesh Kumar K.V9dd540e2012-07-31 16:42:15 -07001279 set_hugetlb_cgroup(page, NULL);
Andi Kleena5516432008-07-23 21:27:41 -07001280 h->nr_huge_pages++;
1281 h->nr_huge_pages_node[nid]++;
Andi Kleenb7ba30c2008-07-23 21:27:40 -07001282 spin_unlock(&hugetlb_lock);
1283 put_page(page); /* free it into the hugepage allocator */
1284}
1285
Kirill A. Shutemovd00181b2015-11-06 16:29:57 -08001286static void prep_compound_gigantic_page(struct page *page, unsigned int order)
Wu Fengguang20a03072009-06-16 15:32:22 -07001287{
1288 int i;
1289 int nr_pages = 1 << order;
1290 struct page *p = page + 1;
1291
1292 /* we rely on prep_new_huge_page to set the destructor */
1293 set_compound_order(page, order);
Andrea Arcangelief5a22b2013-10-16 13:46:56 -07001294 __ClearPageReserved(page);
Kirill A. Shutemovde09d312016-01-15 16:51:42 -08001295 __SetPageHead(page);
Wu Fengguang20a03072009-06-16 15:32:22 -07001296 for (i = 1; i < nr_pages; i++, p = mem_map_next(p, page, i)) {
Andrea Arcangelief5a22b2013-10-16 13:46:56 -07001297 /*
1298 * For gigantic hugepages allocated through bootmem at
1299 * boot, it's safer to be consistent with the not-gigantic
1300 * hugepages and clear the PG_reserved bit from all tail pages
1301 * too. Otherwse drivers using get_user_pages() to access tail
1302 * pages may get the reference counting wrong if they see
1303 * PG_reserved set on a tail page (despite the head page not
1304 * having PG_reserved set). Enforcing this consistency between
1305 * head and tail pages allows drivers to optimize away a check
1306 * on the head page when they need know if put_page() is needed
1307 * after get_user_pages().
1308 */
1309 __ClearPageReserved(p);
Youquan Song58a84aa2011-12-08 14:34:18 -08001310 set_page_count(p, 0);
Kirill A. Shutemov1d798ca2015-11-06 16:29:54 -08001311 set_compound_head(p, page);
Wu Fengguang20a03072009-06-16 15:32:22 -07001312 }
Mike Kravetzb4330af2016-02-05 15:36:38 -08001313 atomic_set(compound_mapcount_ptr(page), -1);
Wu Fengguang20a03072009-06-16 15:32:22 -07001314}
1315
Andrew Morton77959122012-10-08 16:34:11 -07001316/*
1317 * PageHuge() only returns true for hugetlbfs pages, but not for normal or
1318 * transparent huge pages. See the PageTransHuge() documentation for more
1319 * details.
1320 */
Wu Fengguang20a03072009-06-16 15:32:22 -07001321int PageHuge(struct page *page)
1322{
Wu Fengguang20a03072009-06-16 15:32:22 -07001323 if (!PageCompound(page))
1324 return 0;
1325
1326 page = compound_head(page);
Kirill A. Shutemovf1e61552015-11-06 16:29:50 -08001327 return page[1].compound_dtor == HUGETLB_PAGE_DTOR;
Wu Fengguang20a03072009-06-16 15:32:22 -07001328}
Naoya Horiguchi43131e12010-05-28 09:29:22 +09001329EXPORT_SYMBOL_GPL(PageHuge);
1330
Andrea Arcangeli27c73ae2013-11-21 14:32:02 -08001331/*
1332 * PageHeadHuge() only returns true for hugetlbfs head page, but not for
1333 * normal or transparent huge pages.
1334 */
1335int PageHeadHuge(struct page *page_head)
1336{
Andrea Arcangeli27c73ae2013-11-21 14:32:02 -08001337 if (!PageHead(page_head))
1338 return 0;
1339
Andrew Morton758f66a2014-01-21 15:48:57 -08001340 return get_compound_page_dtor(page_head) == free_huge_page;
Andrea Arcangeli27c73ae2013-11-21 14:32:02 -08001341}
Andrea Arcangeli27c73ae2013-11-21 14:32:02 -08001342
Zhang Yi13d60f42013-06-25 21:19:31 +08001343pgoff_t __basepage_index(struct page *page)
1344{
1345 struct page *page_head = compound_head(page);
1346 pgoff_t index = page_index(page_head);
1347 unsigned long compound_idx;
1348
1349 if (!PageHuge(page_head))
1350 return page_index(page);
1351
1352 if (compound_order(page_head) >= MAX_ORDER)
1353 compound_idx = page_to_pfn(page) - page_to_pfn(page_head);
1354 else
1355 compound_idx = page - page_head;
1356
1357 return (index << compound_order(page_head)) + compound_idx;
1358}
1359
Andi Kleena5516432008-07-23 21:27:41 -07001360static struct page *alloc_fresh_huge_page_node(struct hstate *h, int nid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 struct page *page;
Joe Jinf96efd52007-07-15 23:38:12 -07001363
Vlastimil Babka96db8002015-09-08 15:03:50 -07001364 page = __alloc_pages_node(nid,
Naoya Horiguchi86cdb462013-09-11 14:22:13 -07001365 htlb_alloc_mask(h)|__GFP_COMP|__GFP_THISNODE|
Nishanth Aravamudan551883a2008-04-29 00:58:26 -07001366 __GFP_REPEAT|__GFP_NOWARN,
Andi Kleena5516432008-07-23 21:27:41 -07001367 huge_page_order(h));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 if (page) {
Andi Kleena5516432008-07-23 21:27:41 -07001369 prep_new_huge_page(h, page, nid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 }
Nishanth Aravamudan63b46132007-10-16 01:26:24 -07001371
1372 return page;
1373}
1374
Joonsoo Kimb2261022013-09-11 14:21:00 -07001375static int alloc_fresh_huge_page(struct hstate *h, nodemask_t *nodes_allowed)
1376{
1377 struct page *page;
1378 int nr_nodes, node;
1379 int ret = 0;
1380
1381 for_each_node_mask_to_alloc(h, nr_nodes, node, nodes_allowed) {
1382 page = alloc_fresh_huge_page_node(h, node);
1383 if (page) {
1384 ret = 1;
1385 break;
1386 }
1387 }
1388
1389 if (ret)
1390 count_vm_event(HTLB_BUDDY_PGALLOC);
1391 else
1392 count_vm_event(HTLB_BUDDY_PGALLOC_FAIL);
1393
1394 return ret;
1395}
1396
Lee Schermerhorne8c5c822009-09-21 17:01:22 -07001397/*
1398 * Free huge page from pool from next node to free.
1399 * Attempt to keep persistent huge pages more or less
1400 * balanced over allowed nodes.
1401 * Called with hugetlb_lock locked.
1402 */
Lee Schermerhorn6ae11b22009-12-14 17:58:16 -08001403static int free_pool_huge_page(struct hstate *h, nodemask_t *nodes_allowed,
1404 bool acct_surplus)
Lee Schermerhorne8c5c822009-09-21 17:01:22 -07001405{
Joonsoo Kimb2261022013-09-11 14:21:00 -07001406 int nr_nodes, node;
Lee Schermerhorne8c5c822009-09-21 17:01:22 -07001407 int ret = 0;
1408
Joonsoo Kimb2261022013-09-11 14:21:00 -07001409 for_each_node_mask_to_free(h, nr_nodes, node, nodes_allowed) {
Lee Schermerhorn685f3452009-09-21 17:01:23 -07001410 /*
1411 * If we're returning unused surplus pages, only examine
1412 * nodes with surplus pages.
1413 */
Joonsoo Kimb2261022013-09-11 14:21:00 -07001414 if ((!acct_surplus || h->surplus_huge_pages_node[node]) &&
1415 !list_empty(&h->hugepage_freelists[node])) {
Lee Schermerhorne8c5c822009-09-21 17:01:22 -07001416 struct page *page =
Joonsoo Kimb2261022013-09-11 14:21:00 -07001417 list_entry(h->hugepage_freelists[node].next,
Lee Schermerhorne8c5c822009-09-21 17:01:22 -07001418 struct page, lru);
1419 list_del(&page->lru);
1420 h->free_huge_pages--;
Joonsoo Kimb2261022013-09-11 14:21:00 -07001421 h->free_huge_pages_node[node]--;
Lee Schermerhorn685f3452009-09-21 17:01:23 -07001422 if (acct_surplus) {
1423 h->surplus_huge_pages--;
Joonsoo Kimb2261022013-09-11 14:21:00 -07001424 h->surplus_huge_pages_node[node]--;
Lee Schermerhorn685f3452009-09-21 17:01:23 -07001425 }
Lee Schermerhorne8c5c822009-09-21 17:01:22 -07001426 update_and_free_page(h, page);
1427 ret = 1;
Lee Schermerhorn9a76db02009-12-14 17:58:15 -08001428 break;
Lee Schermerhorne8c5c822009-09-21 17:01:22 -07001429 }
Joonsoo Kimb2261022013-09-11 14:21:00 -07001430 }
Lee Schermerhorne8c5c822009-09-21 17:01:22 -07001431
1432 return ret;
1433}
1434
Naoya Horiguchic8721bb2013-09-11 14:22:09 -07001435/*
1436 * Dissolve a given free hugepage into free buddy pages. This function does
1437 * nothing for in-use (including surplus) hugepages.
1438 */
1439static void dissolve_free_huge_page(struct page *page)
1440{
1441 spin_lock(&hugetlb_lock);
1442 if (PageHuge(page) && !page_count(page)) {
1443 struct hstate *h = page_hstate(page);
1444 int nid = page_to_nid(page);
1445 list_del(&page->lru);
1446 h->free_huge_pages--;
1447 h->free_huge_pages_node[nid]--;
1448 update_and_free_page(h, page);
1449 }
1450 spin_unlock(&hugetlb_lock);
1451}
1452
1453/*
1454 * Dissolve free hugepages in a given pfn range. Used by memory hotplug to
1455 * make specified memory blocks removable from the system.
1456 * Note that start_pfn should aligned with (minimum) hugepage size.
1457 */
1458void dissolve_free_huge_pages(unsigned long start_pfn, unsigned long end_pfn)
1459{
Naoya Horiguchic8721bb2013-09-11 14:22:09 -07001460 unsigned long pfn;
Naoya Horiguchic8721bb2013-09-11 14:22:09 -07001461
Li Zhongd0177632014-08-06 16:07:56 -07001462 if (!hugepages_supported())
1463 return;
1464
Naoya Horiguchi641844f2015-06-24 16:56:59 -07001465 VM_BUG_ON(!IS_ALIGNED(start_pfn, 1 << minimum_order));
1466 for (pfn = start_pfn; pfn < end_pfn; pfn += 1 << minimum_order)
Naoya Horiguchic8721bb2013-09-11 14:22:09 -07001467 dissolve_free_huge_page(pfn_to_page(pfn));
1468}
1469
Dave Hansen099730d2015-11-05 18:50:17 -08001470/*
1471 * There are 3 ways this can get called:
1472 * 1. With vma+addr: we use the VMA's memory policy
1473 * 2. With !vma, but nid=NUMA_NO_NODE: We try to allocate a huge
1474 * page from any node, and let the buddy allocator itself figure
1475 * it out.
1476 * 3. With !vma, but nid!=NUMA_NO_NODE. We allocate a huge page
1477 * strictly from 'nid'
1478 */
1479static struct page *__hugetlb_alloc_buddy_huge_page(struct hstate *h,
1480 struct vm_area_struct *vma, unsigned long addr, int nid)
1481{
1482 int order = huge_page_order(h);
1483 gfp_t gfp = htlb_alloc_mask(h)|__GFP_COMP|__GFP_REPEAT|__GFP_NOWARN;
1484 unsigned int cpuset_mems_cookie;
1485
1486 /*
1487 * We need a VMA to get a memory policy. If we do not
Dave Hansene0ec90e2015-11-05 18:50:20 -08001488 * have one, we use the 'nid' argument.
1489 *
1490 * The mempolicy stuff below has some non-inlined bits
1491 * and calls ->vm_ops. That makes it hard to optimize at
1492 * compile-time, even when NUMA is off and it does
1493 * nothing. This helps the compiler optimize it out.
Dave Hansen099730d2015-11-05 18:50:17 -08001494 */
Dave Hansene0ec90e2015-11-05 18:50:20 -08001495 if (!IS_ENABLED(CONFIG_NUMA) || !vma) {
Dave Hansen099730d2015-11-05 18:50:17 -08001496 /*
1497 * If a specific node is requested, make sure to
1498 * get memory from there, but only when a node
1499 * is explicitly specified.
1500 */
1501 if (nid != NUMA_NO_NODE)
1502 gfp |= __GFP_THISNODE;
1503 /*
1504 * Make sure to call something that can handle
1505 * nid=NUMA_NO_NODE
1506 */
1507 return alloc_pages_node(nid, gfp, order);
1508 }
1509
1510 /*
1511 * OK, so we have a VMA. Fetch the mempolicy and try to
Dave Hansene0ec90e2015-11-05 18:50:20 -08001512 * allocate a huge page with it. We will only reach this
1513 * when CONFIG_NUMA=y.
Dave Hansen099730d2015-11-05 18:50:17 -08001514 */
1515 do {
1516 struct page *page;
1517 struct mempolicy *mpol;
1518 struct zonelist *zl;
1519 nodemask_t *nodemask;
1520
1521 cpuset_mems_cookie = read_mems_allowed_begin();
1522 zl = huge_zonelist(vma, addr, gfp, &mpol, &nodemask);
1523 mpol_cond_put(mpol);
1524 page = __alloc_pages_nodemask(gfp, order, zl, nodemask);
1525 if (page)
1526 return page;
1527 } while (read_mems_allowed_retry(cpuset_mems_cookie));
1528
1529 return NULL;
1530}
1531
1532/*
1533 * There are two ways to allocate a huge page:
1534 * 1. When you have a VMA and an address (like a fault)
1535 * 2. When you have no VMA (like when setting /proc/.../nr_hugepages)
1536 *
1537 * 'vma' and 'addr' are only for (1). 'nid' is always NUMA_NO_NODE in
1538 * this case which signifies that the allocation should be done with
1539 * respect for the VMA's memory policy.
1540 *
1541 * For (2), we ignore 'vma' and 'addr' and use 'nid' exclusively. This
1542 * implies that memory policies will not be taken in to account.
1543 */
1544static struct page *__alloc_buddy_huge_page(struct hstate *h,
1545 struct vm_area_struct *vma, unsigned long addr, int nid)
Adam Litke7893d1d2007-10-16 01:26:18 -07001546{
1547 struct page *page;
Naoya Horiguchibf50bab2010-09-08 10:19:33 +09001548 unsigned int r_nid;
Adam Litke7893d1d2007-10-16 01:26:18 -07001549
Luiz Capitulinobae7f4a2014-06-04 16:07:08 -07001550 if (hstate_is_gigantic(h))
Andi Kleenaa888a72008-07-23 21:27:47 -07001551 return NULL;
1552
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08001553 /*
Dave Hansen099730d2015-11-05 18:50:17 -08001554 * Make sure that anyone specifying 'nid' is not also specifying a VMA.
1555 * This makes sure the caller is picking _one_ of the modes with which
1556 * we can call this function, not both.
1557 */
1558 if (vma || (addr != -1)) {
Dave Hansene0ec90e2015-11-05 18:50:20 -08001559 VM_WARN_ON_ONCE(addr == -1);
1560 VM_WARN_ON_ONCE(nid != NUMA_NO_NODE);
Dave Hansen099730d2015-11-05 18:50:17 -08001561 }
1562 /*
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08001563 * Assume we will successfully allocate the surplus page to
1564 * prevent racing processes from causing the surplus to exceed
1565 * overcommit
1566 *
1567 * This however introduces a different race, where a process B
1568 * tries to grow the static hugepage pool while alloc_pages() is
1569 * called by process A. B will only examine the per-node
1570 * counters in determining if surplus huge pages can be
1571 * converted to normal huge pages in adjust_pool_surplus(). A
1572 * won't be able to increment the per-node counter, until the
1573 * lock is dropped by B, but B doesn't drop hugetlb_lock until
1574 * no more huge pages can be converted from surplus to normal
1575 * state (and doesn't try to convert again). Thus, we have a
1576 * case where a surplus huge page exists, the pool is grown, and
1577 * the surplus huge page still exists after, even though it
1578 * should just have been converted to a normal huge page. This
1579 * does not leak memory, though, as the hugepage will be freed
1580 * once it is out of use. It also does not allow the counters to
1581 * go out of whack in adjust_pool_surplus() as we don't modify
1582 * the node values until we've gotten the hugepage and only the
1583 * per-node value is checked there.
1584 */
1585 spin_lock(&hugetlb_lock);
Andi Kleena5516432008-07-23 21:27:41 -07001586 if (h->surplus_huge_pages >= h->nr_overcommit_huge_pages) {
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08001587 spin_unlock(&hugetlb_lock);
1588 return NULL;
1589 } else {
Andi Kleena5516432008-07-23 21:27:41 -07001590 h->nr_huge_pages++;
1591 h->surplus_huge_pages++;
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08001592 }
1593 spin_unlock(&hugetlb_lock);
1594
Dave Hansen099730d2015-11-05 18:50:17 -08001595 page = __hugetlb_alloc_buddy_huge_page(h, vma, addr, nid);
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08001596
1597 spin_lock(&hugetlb_lock);
Adam Litke7893d1d2007-10-16 01:26:18 -07001598 if (page) {
Aneesh Kumar K.V0edaecf2012-07-31 16:42:07 -07001599 INIT_LIST_HEAD(&page->lru);
Naoya Horiguchibf50bab2010-09-08 10:19:33 +09001600 r_nid = page_to_nid(page);
Kirill A. Shutemovf1e61552015-11-06 16:29:50 -08001601 set_compound_page_dtor(page, HUGETLB_PAGE_DTOR);
Aneesh Kumar K.V9dd540e2012-07-31 16:42:15 -07001602 set_hugetlb_cgroup(page, NULL);
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08001603 /*
1604 * We incremented the global counters already
1605 */
Naoya Horiguchibf50bab2010-09-08 10:19:33 +09001606 h->nr_huge_pages_node[r_nid]++;
1607 h->surplus_huge_pages_node[r_nid]++;
Adam Litke3b116302008-04-28 02:13:06 -07001608 __count_vm_event(HTLB_BUDDY_PGALLOC);
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08001609 } else {
Andi Kleena5516432008-07-23 21:27:41 -07001610 h->nr_huge_pages--;
1611 h->surplus_huge_pages--;
Adam Litke3b116302008-04-28 02:13:06 -07001612 __count_vm_event(HTLB_BUDDY_PGALLOC_FAIL);
Adam Litke7893d1d2007-10-16 01:26:18 -07001613 }
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08001614 spin_unlock(&hugetlb_lock);
Adam Litke7893d1d2007-10-16 01:26:18 -07001615
1616 return page;
1617}
1618
Adam Litkee4e574b2007-10-16 01:26:19 -07001619/*
Dave Hansen099730d2015-11-05 18:50:17 -08001620 * Allocate a huge page from 'nid'. Note, 'nid' may be
1621 * NUMA_NO_NODE, which means that it may be allocated
1622 * anywhere.
1623 */
Dave Hansene0ec90e2015-11-05 18:50:20 -08001624static
Dave Hansen099730d2015-11-05 18:50:17 -08001625struct page *__alloc_buddy_huge_page_no_mpol(struct hstate *h, int nid)
1626{
1627 unsigned long addr = -1;
1628
1629 return __alloc_buddy_huge_page(h, NULL, addr, nid);
1630}
1631
1632/*
1633 * Use the VMA's mpolicy to allocate a huge page from the buddy.
1634 */
Dave Hansene0ec90e2015-11-05 18:50:20 -08001635static
Dave Hansen099730d2015-11-05 18:50:17 -08001636struct page *__alloc_buddy_huge_page_with_mpol(struct hstate *h,
1637 struct vm_area_struct *vma, unsigned long addr)
1638{
1639 return __alloc_buddy_huge_page(h, vma, addr, NUMA_NO_NODE);
1640}
1641
1642/*
Naoya Horiguchibf50bab2010-09-08 10:19:33 +09001643 * This allocation function is useful in the context where vma is irrelevant.
1644 * E.g. soft-offlining uses this function because it only cares physical
1645 * address of error page.
1646 */
1647struct page *alloc_huge_page_node(struct hstate *h, int nid)
1648{
Joonsoo Kim4ef91842013-09-11 14:21:51 -07001649 struct page *page = NULL;
Naoya Horiguchibf50bab2010-09-08 10:19:33 +09001650
1651 spin_lock(&hugetlb_lock);
Joonsoo Kim4ef91842013-09-11 14:21:51 -07001652 if (h->free_huge_pages - h->resv_huge_pages > 0)
1653 page = dequeue_huge_page_node(h, nid);
Naoya Horiguchibf50bab2010-09-08 10:19:33 +09001654 spin_unlock(&hugetlb_lock);
1655
Aneesh Kumar K.V94ae8ba2012-07-31 16:42:35 -07001656 if (!page)
Dave Hansen099730d2015-11-05 18:50:17 -08001657 page = __alloc_buddy_huge_page_no_mpol(h, nid);
Naoya Horiguchibf50bab2010-09-08 10:19:33 +09001658
1659 return page;
1660}
1661
1662/*
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001663 * Increase the hugetlb pool such that it can accommodate a reservation
Adam Litkee4e574b2007-10-16 01:26:19 -07001664 * of size 'delta'.
1665 */
Andi Kleena5516432008-07-23 21:27:41 -07001666static int gather_surplus_pages(struct hstate *h, int delta)
Adam Litkee4e574b2007-10-16 01:26:19 -07001667{
1668 struct list_head surplus_list;
1669 struct page *page, *tmp;
1670 int ret, i;
1671 int needed, allocated;
Hillf Danton28073b02012-03-21 16:34:00 -07001672 bool alloc_ok = true;
Adam Litkee4e574b2007-10-16 01:26:19 -07001673
Andi Kleena5516432008-07-23 21:27:41 -07001674 needed = (h->resv_huge_pages + delta) - h->free_huge_pages;
Adam Litkeac09b3a2008-03-04 14:29:38 -08001675 if (needed <= 0) {
Andi Kleena5516432008-07-23 21:27:41 -07001676 h->resv_huge_pages += delta;
Adam Litkee4e574b2007-10-16 01:26:19 -07001677 return 0;
Adam Litkeac09b3a2008-03-04 14:29:38 -08001678 }
Adam Litkee4e574b2007-10-16 01:26:19 -07001679
1680 allocated = 0;
1681 INIT_LIST_HEAD(&surplus_list);
1682
1683 ret = -ENOMEM;
1684retry:
1685 spin_unlock(&hugetlb_lock);
1686 for (i = 0; i < needed; i++) {
Dave Hansen099730d2015-11-05 18:50:17 -08001687 page = __alloc_buddy_huge_page_no_mpol(h, NUMA_NO_NODE);
Hillf Danton28073b02012-03-21 16:34:00 -07001688 if (!page) {
1689 alloc_ok = false;
1690 break;
1691 }
Adam Litkee4e574b2007-10-16 01:26:19 -07001692 list_add(&page->lru, &surplus_list);
1693 }
Hillf Danton28073b02012-03-21 16:34:00 -07001694 allocated += i;
Adam Litkee4e574b2007-10-16 01:26:19 -07001695
1696 /*
1697 * After retaking hugetlb_lock, we need to recalculate 'needed'
1698 * because either resv_huge_pages or free_huge_pages may have changed.
1699 */
1700 spin_lock(&hugetlb_lock);
Andi Kleena5516432008-07-23 21:27:41 -07001701 needed = (h->resv_huge_pages + delta) -
1702 (h->free_huge_pages + allocated);
Hillf Danton28073b02012-03-21 16:34:00 -07001703 if (needed > 0) {
1704 if (alloc_ok)
1705 goto retry;
1706 /*
1707 * We were not able to allocate enough pages to
1708 * satisfy the entire reservation so we free what
1709 * we've allocated so far.
1710 */
1711 goto free;
1712 }
Adam Litkee4e574b2007-10-16 01:26:19 -07001713 /*
1714 * The surplus_list now contains _at_least_ the number of extra pages
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001715 * needed to accommodate the reservation. Add the appropriate number
Adam Litkee4e574b2007-10-16 01:26:19 -07001716 * of pages to the hugetlb pool and free the extras back to the buddy
Adam Litkeac09b3a2008-03-04 14:29:38 -08001717 * allocator. Commit the entire reservation here to prevent another
1718 * process from stealing the pages as they are added to the pool but
1719 * before they are reserved.
Adam Litkee4e574b2007-10-16 01:26:19 -07001720 */
1721 needed += allocated;
Andi Kleena5516432008-07-23 21:27:41 -07001722 h->resv_huge_pages += delta;
Adam Litkee4e574b2007-10-16 01:26:19 -07001723 ret = 0;
Naoya Horiguchia9869b82010-09-08 10:19:37 +09001724
Adam Litke19fc3f02008-04-28 02:12:20 -07001725 /* Free the needed pages to the hugetlb pool */
Adam Litkee4e574b2007-10-16 01:26:19 -07001726 list_for_each_entry_safe(page, tmp, &surplus_list, lru) {
Adam Litke19fc3f02008-04-28 02:12:20 -07001727 if ((--needed) < 0)
1728 break;
Naoya Horiguchia9869b82010-09-08 10:19:37 +09001729 /*
1730 * This page is now managed by the hugetlb allocator and has
1731 * no users -- drop the buddy allocator's reference.
1732 */
1733 put_page_testzero(page);
Sasha Levin309381fea2014-01-23 15:52:54 -08001734 VM_BUG_ON_PAGE(page_count(page), page);
Andi Kleena5516432008-07-23 21:27:41 -07001735 enqueue_huge_page(h, page);
Adam Litke19fc3f02008-04-28 02:12:20 -07001736 }
Hillf Danton28073b02012-03-21 16:34:00 -07001737free:
Hillf Dantonb0365c82011-12-28 15:57:16 -08001738 spin_unlock(&hugetlb_lock);
Adam Litke19fc3f02008-04-28 02:12:20 -07001739
1740 /* Free unnecessary surplus pages to the buddy allocator */
Joonsoo Kimc0d934b2013-09-11 14:21:02 -07001741 list_for_each_entry_safe(page, tmp, &surplus_list, lru)
1742 put_page(page);
Naoya Horiguchia9869b82010-09-08 10:19:37 +09001743 spin_lock(&hugetlb_lock);
Adam Litkee4e574b2007-10-16 01:26:19 -07001744
1745 return ret;
1746}
1747
1748/*
1749 * When releasing a hugetlb pool reservation, any surplus pages that were
1750 * allocated to satisfy the reservation must be explicitly freed if they were
1751 * never used.
Lee Schermerhorn685f3452009-09-21 17:01:23 -07001752 * Called with hugetlb_lock held.
Adam Litkee4e574b2007-10-16 01:26:19 -07001753 */
Andi Kleena5516432008-07-23 21:27:41 -07001754static void return_unused_surplus_pages(struct hstate *h,
1755 unsigned long unused_resv_pages)
Adam Litkee4e574b2007-10-16 01:26:19 -07001756{
Adam Litkee4e574b2007-10-16 01:26:19 -07001757 unsigned long nr_pages;
1758
Adam Litkeac09b3a2008-03-04 14:29:38 -08001759 /* Uncommit the reservation */
Andi Kleena5516432008-07-23 21:27:41 -07001760 h->resv_huge_pages -= unused_resv_pages;
Adam Litkeac09b3a2008-03-04 14:29:38 -08001761
Andi Kleenaa888a72008-07-23 21:27:47 -07001762 /* Cannot return gigantic pages currently */
Luiz Capitulinobae7f4a2014-06-04 16:07:08 -07001763 if (hstate_is_gigantic(h))
Andi Kleenaa888a72008-07-23 21:27:47 -07001764 return;
1765
Andi Kleena5516432008-07-23 21:27:41 -07001766 nr_pages = min(unused_resv_pages, h->surplus_huge_pages);
Adam Litkee4e574b2007-10-16 01:26:19 -07001767
Lee Schermerhorn685f3452009-09-21 17:01:23 -07001768 /*
1769 * We want to release as many surplus pages as possible, spread
Lee Schermerhorn9b5e5d02009-12-14 17:58:32 -08001770 * evenly across all nodes with memory. Iterate across these nodes
1771 * until we can no longer free unreserved surplus pages. This occurs
1772 * when the nodes with surplus pages have no free pages.
1773 * free_pool_huge_page() will balance the the freed pages across the
1774 * on-line nodes with memory and will handle the hstate accounting.
Lee Schermerhorn685f3452009-09-21 17:01:23 -07001775 */
1776 while (nr_pages--) {
Lai Jiangshan8cebfcd2012-12-12 13:51:36 -08001777 if (!free_pool_huge_page(h, &node_states[N_MEMORY], 1))
Lee Schermerhorn685f3452009-09-21 17:01:23 -07001778 break;
Mizuma, Masayoshi7848a4b2014-04-18 15:07:18 -07001779 cond_resched_lock(&hugetlb_lock);
Adam Litkee4e574b2007-10-16 01:26:19 -07001780 }
1781}
1782
Mike Kravetz5e911372015-09-08 15:01:28 -07001783
Andy Whitcroftc37f9fb2008-07-23 21:27:30 -07001784/*
Mike Kravetzfeba16e2015-09-08 15:01:31 -07001785 * vma_needs_reservation, vma_commit_reservation and vma_end_reservation
Mike Kravetz5e911372015-09-08 15:01:28 -07001786 * are used by the huge page allocation routines to manage reservations.
Mike Kravetzcf3ad202015-06-24 16:57:55 -07001787 *
1788 * vma_needs_reservation is called to determine if the huge page at addr
1789 * within the vma has an associated reservation. If a reservation is
1790 * needed, the value 1 is returned. The caller is then responsible for
1791 * managing the global reservation and subpool usage counts. After
1792 * the huge page has been allocated, vma_commit_reservation is called
Mike Kravetzfeba16e2015-09-08 15:01:31 -07001793 * to add the page to the reservation map. If the page allocation fails,
1794 * the reservation must be ended instead of committed. vma_end_reservation
1795 * is called in such cases.
Mike Kravetzcf3ad202015-06-24 16:57:55 -07001796 *
1797 * In the normal case, vma_commit_reservation returns the same value
1798 * as the preceding vma_needs_reservation call. The only time this
1799 * is not the case is if a reserve map was changed between calls. It
1800 * is the responsibility of the caller to notice the difference and
1801 * take appropriate action.
Andy Whitcroftc37f9fb2008-07-23 21:27:30 -07001802 */
Mike Kravetz5e911372015-09-08 15:01:28 -07001803enum vma_resv_mode {
1804 VMA_NEEDS_RESV,
1805 VMA_COMMIT_RESV,
Mike Kravetzfeba16e2015-09-08 15:01:31 -07001806 VMA_END_RESV,
Mike Kravetz5e911372015-09-08 15:01:28 -07001807};
Mike Kravetzcf3ad202015-06-24 16:57:55 -07001808static long __vma_reservation_common(struct hstate *h,
1809 struct vm_area_struct *vma, unsigned long addr,
Mike Kravetz5e911372015-09-08 15:01:28 -07001810 enum vma_resv_mode mode)
Andy Whitcroftc37f9fb2008-07-23 21:27:30 -07001811{
Joonsoo Kim4e35f482014-04-03 14:47:30 -07001812 struct resv_map *resv;
1813 pgoff_t idx;
Mike Kravetzcf3ad202015-06-24 16:57:55 -07001814 long ret;
Andy Whitcroftc37f9fb2008-07-23 21:27:30 -07001815
Joonsoo Kim4e35f482014-04-03 14:47:30 -07001816 resv = vma_resv_map(vma);
1817 if (!resv)
Andy Whitcroft84afd992008-07-23 21:27:32 -07001818 return 1;
Andy Whitcroftc37f9fb2008-07-23 21:27:30 -07001819
Joonsoo Kim4e35f482014-04-03 14:47:30 -07001820 idx = vma_hugecache_offset(h, vma, addr);
Mike Kravetz5e911372015-09-08 15:01:28 -07001821 switch (mode) {
1822 case VMA_NEEDS_RESV:
Mike Kravetzcf3ad202015-06-24 16:57:55 -07001823 ret = region_chg(resv, idx, idx + 1);
Mike Kravetz5e911372015-09-08 15:01:28 -07001824 break;
1825 case VMA_COMMIT_RESV:
1826 ret = region_add(resv, idx, idx + 1);
1827 break;
Mike Kravetzfeba16e2015-09-08 15:01:31 -07001828 case VMA_END_RESV:
Mike Kravetz5e911372015-09-08 15:01:28 -07001829 region_abort(resv, idx, idx + 1);
1830 ret = 0;
1831 break;
1832 default:
1833 BUG();
1834 }
Andy Whitcroft84afd992008-07-23 21:27:32 -07001835
Joonsoo Kim4e35f482014-04-03 14:47:30 -07001836 if (vma->vm_flags & VM_MAYSHARE)
Mike Kravetzcf3ad202015-06-24 16:57:55 -07001837 return ret;
Mike Kravetz67961f92016-06-08 15:33:42 -07001838 else if (is_vma_resv_set(vma, HPAGE_RESV_OWNER) && ret >= 0) {
1839 /*
1840 * In most cases, reserves always exist for private mappings.
1841 * However, a file associated with mapping could have been
1842 * hole punched or truncated after reserves were consumed.
1843 * As subsequent fault on such a range will not use reserves.
1844 * Subtle - The reserve map for private mappings has the
1845 * opposite meaning than that of shared mappings. If NO
1846 * entry is in the reserve map, it means a reservation exists.
1847 * If an entry exists in the reserve map, it means the
1848 * reservation has already been consumed. As a result, the
1849 * return value of this routine is the opposite of the
1850 * value returned from reserve map manipulation routines above.
1851 */
1852 if (ret)
1853 return 0;
1854 else
1855 return 1;
1856 }
Joonsoo Kim4e35f482014-04-03 14:47:30 -07001857 else
Mike Kravetzcf3ad202015-06-24 16:57:55 -07001858 return ret < 0 ? ret : 0;
Andy Whitcroftc37f9fb2008-07-23 21:27:30 -07001859}
Mike Kravetzcf3ad202015-06-24 16:57:55 -07001860
1861static long vma_needs_reservation(struct hstate *h,
Andi Kleena5516432008-07-23 21:27:41 -07001862 struct vm_area_struct *vma, unsigned long addr)
Andy Whitcroftc37f9fb2008-07-23 21:27:30 -07001863{
Mike Kravetz5e911372015-09-08 15:01:28 -07001864 return __vma_reservation_common(h, vma, addr, VMA_NEEDS_RESV);
Mike Kravetzcf3ad202015-06-24 16:57:55 -07001865}
Andy Whitcroftc37f9fb2008-07-23 21:27:30 -07001866
Mike Kravetzcf3ad202015-06-24 16:57:55 -07001867static long vma_commit_reservation(struct hstate *h,
1868 struct vm_area_struct *vma, unsigned long addr)
1869{
Mike Kravetz5e911372015-09-08 15:01:28 -07001870 return __vma_reservation_common(h, vma, addr, VMA_COMMIT_RESV);
1871}
1872
Mike Kravetzfeba16e2015-09-08 15:01:31 -07001873static void vma_end_reservation(struct hstate *h,
Mike Kravetz5e911372015-09-08 15:01:28 -07001874 struct vm_area_struct *vma, unsigned long addr)
1875{
Mike Kravetzfeba16e2015-09-08 15:01:31 -07001876 (void)__vma_reservation_common(h, vma, addr, VMA_END_RESV);
Andy Whitcroftc37f9fb2008-07-23 21:27:30 -07001877}
1878
Mike Kravetz70c35472015-09-08 15:01:54 -07001879struct page *alloc_huge_page(struct vm_area_struct *vma,
Mel Gorman04f2cbe2008-07-23 21:27:25 -07001880 unsigned long addr, int avoid_reserve)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881{
David Gibson90481622012-03-21 16:34:12 -07001882 struct hugepage_subpool *spool = subpool_vma(vma);
Andi Kleena5516432008-07-23 21:27:41 -07001883 struct hstate *h = hstate_vma(vma);
Adam Litke348ea202007-11-14 16:59:37 -08001884 struct page *page;
Mike Kravetzd85f69b2015-09-08 15:01:47 -07001885 long map_chg, map_commit;
1886 long gbl_chg;
Aneesh Kumar K.V6d76dcf2012-07-31 16:42:18 -07001887 int ret, idx;
1888 struct hugetlb_cgroup *h_cg;
Adam Litke2fc39ce2007-11-14 16:59:39 -08001889
Aneesh Kumar K.V6d76dcf2012-07-31 16:42:18 -07001890 idx = hstate_index(h);
Mel Gormana1e78772008-07-23 21:27:23 -07001891 /*
Mike Kravetzd85f69b2015-09-08 15:01:47 -07001892 * Examine the region/reserve map to determine if the process
1893 * has a reservation for the page to be allocated. A return
1894 * code of zero indicates a reservation exists (no change).
Mel Gormana1e78772008-07-23 21:27:23 -07001895 */
Mike Kravetzd85f69b2015-09-08 15:01:47 -07001896 map_chg = gbl_chg = vma_needs_reservation(h, vma, addr);
1897 if (map_chg < 0)
Aneesh Kumar K.V76dcee72012-07-31 16:41:57 -07001898 return ERR_PTR(-ENOMEM);
Mike Kravetzd85f69b2015-09-08 15:01:47 -07001899
1900 /*
1901 * Processes that did not create the mapping will have no
1902 * reserves as indicated by the region/reserve map. Check
1903 * that the allocation will not exceed the subpool limit.
1904 * Allocations for MAP_NORESERVE mappings also need to be
1905 * checked against any subpool limit.
1906 */
1907 if (map_chg || avoid_reserve) {
1908 gbl_chg = hugepage_subpool_get_pages(spool, 1);
1909 if (gbl_chg < 0) {
Mike Kravetzfeba16e2015-09-08 15:01:31 -07001910 vma_end_reservation(h, vma, addr);
Aneesh Kumar K.V76dcee72012-07-31 16:41:57 -07001911 return ERR_PTR(-ENOSPC);
Mike Kravetz5e911372015-09-08 15:01:28 -07001912 }
Mel Gormana1e78772008-07-23 21:27:23 -07001913
Mike Kravetzd85f69b2015-09-08 15:01:47 -07001914 /*
1915 * Even though there was no reservation in the region/reserve
1916 * map, there could be reservations associated with the
1917 * subpool that can be used. This would be indicated if the
1918 * return value of hugepage_subpool_get_pages() is zero.
1919 * However, if avoid_reserve is specified we still avoid even
1920 * the subpool reservations.
1921 */
1922 if (avoid_reserve)
1923 gbl_chg = 1;
1924 }
1925
Aneesh Kumar K.V6d76dcf2012-07-31 16:42:18 -07001926 ret = hugetlb_cgroup_charge_cgroup(idx, pages_per_huge_page(h), &h_cg);
Jianyu Zhan8f34af62014-06-04 16:10:36 -07001927 if (ret)
1928 goto out_subpool_put;
1929
Mel Gormana1e78772008-07-23 21:27:23 -07001930 spin_lock(&hugetlb_lock);
Mike Kravetzd85f69b2015-09-08 15:01:47 -07001931 /*
1932 * glb_chg is passed to indicate whether or not a page must be taken
1933 * from the global free pool (global change). gbl_chg == 0 indicates
1934 * a reservation exists for the allocation.
1935 */
1936 page = dequeue_huge_page_vma(h, vma, addr, avoid_reserve, gbl_chg);
Joonsoo Kim81a6fca2013-09-11 14:20:58 -07001937 if (!page) {
Aneesh Kumar K.V94ae8ba2012-07-31 16:42:35 -07001938 spin_unlock(&hugetlb_lock);
Dave Hansen099730d2015-11-05 18:50:17 -08001939 page = __alloc_buddy_huge_page_with_mpol(h, vma, addr);
Jianyu Zhan8f34af62014-06-04 16:10:36 -07001940 if (!page)
1941 goto out_uncharge_cgroup;
Naoya Horiguchia88c7692015-12-11 13:40:24 -08001942 if (!avoid_reserve && vma_has_reserves(vma, gbl_chg)) {
1943 SetPagePrivate(page);
1944 h->resv_huge_pages--;
1945 }
Aneesh Kumar K.V79dbb232012-07-31 16:42:32 -07001946 spin_lock(&hugetlb_lock);
1947 list_move(&page->lru, &h->hugepage_activelist);
Joonsoo Kim81a6fca2013-09-11 14:20:58 -07001948 /* Fall through */
Mel Gormana1e78772008-07-23 21:27:23 -07001949 }
Joonsoo Kim81a6fca2013-09-11 14:20:58 -07001950 hugetlb_cgroup_commit_charge(idx, pages_per_huge_page(h), h_cg, page);
1951 spin_unlock(&hugetlb_lock);
Mel Gormana1e78772008-07-23 21:27:23 -07001952
David Gibson90481622012-03-21 16:34:12 -07001953 set_page_private(page, (unsigned long)spool);
Mel Gormana1e78772008-07-23 21:27:23 -07001954
Mike Kravetzd85f69b2015-09-08 15:01:47 -07001955 map_commit = vma_commit_reservation(h, vma, addr);
1956 if (unlikely(map_chg > map_commit)) {
Mike Kravetz33039672015-06-24 16:57:58 -07001957 /*
1958 * The page was added to the reservation map between
1959 * vma_needs_reservation and vma_commit_reservation.
1960 * This indicates a race with hugetlb_reserve_pages.
1961 * Adjust for the subpool count incremented above AND
1962 * in hugetlb_reserve_pages for the same page. Also,
1963 * the reservation count added in hugetlb_reserve_pages
1964 * no longer applies.
1965 */
1966 long rsv_adjust;
1967
1968 rsv_adjust = hugepage_subpool_put_pages(spool, 1);
1969 hugetlb_acct_memory(h, -rsv_adjust);
1970 }
Adam Litke90d8b7e2007-11-14 16:59:42 -08001971 return page;
Jianyu Zhan8f34af62014-06-04 16:10:36 -07001972
1973out_uncharge_cgroup:
1974 hugetlb_cgroup_uncharge_cgroup(idx, pages_per_huge_page(h), h_cg);
1975out_subpool_put:
Mike Kravetzd85f69b2015-09-08 15:01:47 -07001976 if (map_chg || avoid_reserve)
Jianyu Zhan8f34af62014-06-04 16:10:36 -07001977 hugepage_subpool_put_pages(spool, 1);
Mike Kravetzfeba16e2015-09-08 15:01:31 -07001978 vma_end_reservation(h, vma, addr);
Jianyu Zhan8f34af62014-06-04 16:10:36 -07001979 return ERR_PTR(-ENOSPC);
David Gibsonb45b5bd2006-03-22 00:08:55 -08001980}
1981
Naoya Horiguchi74060e42013-09-11 14:22:06 -07001982/*
1983 * alloc_huge_page()'s wrapper which simply returns the page if allocation
1984 * succeeds, otherwise NULL. This function is called from new_vma_page(),
1985 * where no ERR_VALUE is expected to be returned.
1986 */
1987struct page *alloc_huge_page_noerr(struct vm_area_struct *vma,
1988 unsigned long addr, int avoid_reserve)
1989{
1990 struct page *page = alloc_huge_page(vma, addr, avoid_reserve);
1991 if (IS_ERR(page))
1992 page = NULL;
1993 return page;
1994}
1995
Cyrill Gorcunov91f47662009-01-06 14:40:33 -08001996int __weak alloc_bootmem_huge_page(struct hstate *h)
Andi Kleenaa888a72008-07-23 21:27:47 -07001997{
1998 struct huge_bootmem_page *m;
Joonsoo Kimb2261022013-09-11 14:21:00 -07001999 int nr_nodes, node;
Andi Kleenaa888a72008-07-23 21:27:47 -07002000
Joonsoo Kimb2261022013-09-11 14:21:00 -07002001 for_each_node_mask_to_alloc(h, nr_nodes, node, &node_states[N_MEMORY]) {
Andi Kleenaa888a72008-07-23 21:27:47 -07002002 void *addr;
2003
Grygorii Strashko8b89a112014-01-21 15:50:36 -08002004 addr = memblock_virt_alloc_try_nid_nopanic(
2005 huge_page_size(h), huge_page_size(h),
2006 0, BOOTMEM_ALLOC_ACCESSIBLE, node);
Andi Kleenaa888a72008-07-23 21:27:47 -07002007 if (addr) {
2008 /*
2009 * Use the beginning of the huge page to store the
2010 * huge_bootmem_page struct (until gather_bootmem
2011 * puts them into the mem_map).
2012 */
2013 m = addr;
Cyrill Gorcunov91f47662009-01-06 14:40:33 -08002014 goto found;
Andi Kleenaa888a72008-07-23 21:27:47 -07002015 }
Andi Kleenaa888a72008-07-23 21:27:47 -07002016 }
2017 return 0;
2018
2019found:
Luiz Capitulinodf994ea2014-12-12 16:55:21 -08002020 BUG_ON(!IS_ALIGNED(virt_to_phys(m), huge_page_size(h)));
Andi Kleenaa888a72008-07-23 21:27:47 -07002021 /* Put them into a private list first because mem_map is not up yet */
2022 list_add(&m->list, &huge_boot_pages);
2023 m->hstate = h;
2024 return 1;
2025}
2026
Kirill A. Shutemovd00181b2015-11-06 16:29:57 -08002027static void __init prep_compound_huge_page(struct page *page,
2028 unsigned int order)
Andy Whitcroft18229df2008-11-06 12:53:27 -08002029{
2030 if (unlikely(order > (MAX_ORDER - 1)))
2031 prep_compound_gigantic_page(page, order);
2032 else
2033 prep_compound_page(page, order);
2034}
2035
Andi Kleenaa888a72008-07-23 21:27:47 -07002036/* Put bootmem huge pages into the standard lists after mem_map is up */
2037static void __init gather_bootmem_prealloc(void)
2038{
2039 struct huge_bootmem_page *m;
2040
2041 list_for_each_entry(m, &huge_boot_pages, list) {
Andi Kleenaa888a72008-07-23 21:27:47 -07002042 struct hstate *h = m->hstate;
Becky Bruceee8f2482011-07-25 17:11:50 -07002043 struct page *page;
2044
2045#ifdef CONFIG_HIGHMEM
2046 page = pfn_to_page(m->phys >> PAGE_SHIFT);
Grygorii Strashko8b89a112014-01-21 15:50:36 -08002047 memblock_free_late(__pa(m),
2048 sizeof(struct huge_bootmem_page));
Becky Bruceee8f2482011-07-25 17:11:50 -07002049#else
2050 page = virt_to_page(m);
2051#endif
Andi Kleenaa888a72008-07-23 21:27:47 -07002052 WARN_ON(page_count(page) != 1);
Andy Whitcroft18229df2008-11-06 12:53:27 -08002053 prep_compound_huge_page(page, h->order);
Andrea Arcangelief5a22b2013-10-16 13:46:56 -07002054 WARN_ON(PageReserved(page));
Andi Kleenaa888a72008-07-23 21:27:47 -07002055 prep_new_huge_page(h, page, page_to_nid(page));
Rafael Aquinib0320c72011-06-15 15:08:39 -07002056 /*
2057 * If we had gigantic hugepages allocated at boot time, we need
2058 * to restore the 'stolen' pages to totalram_pages in order to
2059 * fix confusing memory reports from free(1) and another
2060 * side-effects, like CommitLimit going negative.
2061 */
Luiz Capitulinobae7f4a2014-06-04 16:07:08 -07002062 if (hstate_is_gigantic(h))
Jiang Liu3dcc0572013-07-03 15:03:21 -07002063 adjust_managed_page_count(page, 1 << h->order);
Andi Kleenaa888a72008-07-23 21:27:47 -07002064 }
2065}
2066
Andi Kleen8faa8b02008-07-23 21:27:48 -07002067static void __init hugetlb_hstate_alloc_pages(struct hstate *h)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068{
2069 unsigned long i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070
Andi Kleene5ff2152008-07-23 21:27:42 -07002071 for (i = 0; i < h->max_huge_pages; ++i) {
Luiz Capitulinobae7f4a2014-06-04 16:07:08 -07002072 if (hstate_is_gigantic(h)) {
Andi Kleenaa888a72008-07-23 21:27:47 -07002073 if (!alloc_bootmem_huge_page(h))
2074 break;
Lee Schermerhorn9b5e5d02009-12-14 17:58:32 -08002075 } else if (!alloc_fresh_huge_page(h,
Lai Jiangshan8cebfcd2012-12-12 13:51:36 -08002076 &node_states[N_MEMORY]))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 }
Andi Kleen8faa8b02008-07-23 21:27:48 -07002079 h->max_huge_pages = i;
Andi Kleene5ff2152008-07-23 21:27:42 -07002080}
2081
2082static void __init hugetlb_init_hstates(void)
2083{
2084 struct hstate *h;
2085
2086 for_each_hstate(h) {
Naoya Horiguchi641844f2015-06-24 16:56:59 -07002087 if (minimum_order > huge_page_order(h))
2088 minimum_order = huge_page_order(h);
2089
Andi Kleen8faa8b02008-07-23 21:27:48 -07002090 /* oversize hugepages were init'ed in early boot */
Luiz Capitulinobae7f4a2014-06-04 16:07:08 -07002091 if (!hstate_is_gigantic(h))
Andi Kleen8faa8b02008-07-23 21:27:48 -07002092 hugetlb_hstate_alloc_pages(h);
Andi Kleene5ff2152008-07-23 21:27:42 -07002093 }
Naoya Horiguchi641844f2015-06-24 16:56:59 -07002094 VM_BUG_ON(minimum_order == UINT_MAX);
Andi Kleene5ff2152008-07-23 21:27:42 -07002095}
2096
Andi Kleen4abd32d2008-07-23 21:27:49 -07002097static char * __init memfmt(char *buf, unsigned long n)
2098{
2099 if (n >= (1UL << 30))
2100 sprintf(buf, "%lu GB", n >> 30);
2101 else if (n >= (1UL << 20))
2102 sprintf(buf, "%lu MB", n >> 20);
2103 else
2104 sprintf(buf, "%lu KB", n >> 10);
2105 return buf;
2106}
2107
Andi Kleene5ff2152008-07-23 21:27:42 -07002108static void __init report_hugepages(void)
2109{
2110 struct hstate *h;
2111
2112 for_each_hstate(h) {
Andi Kleen4abd32d2008-07-23 21:27:49 -07002113 char buf[32];
Andrew Mortonffb22af2013-02-22 16:32:08 -08002114 pr_info("HugeTLB registered %s page size, pre-allocated %ld pages\n",
Andi Kleen4abd32d2008-07-23 21:27:49 -07002115 memfmt(buf, huge_page_size(h)),
2116 h->free_huge_pages);
Andi Kleene5ff2152008-07-23 21:27:42 -07002117 }
2118}
2119
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120#ifdef CONFIG_HIGHMEM
Lee Schermerhorn6ae11b22009-12-14 17:58:16 -08002121static void try_to_free_low(struct hstate *h, unsigned long count,
2122 nodemask_t *nodes_allowed)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123{
Christoph Lameter4415cc82006-09-25 23:31:55 -07002124 int i;
2125
Luiz Capitulinobae7f4a2014-06-04 16:07:08 -07002126 if (hstate_is_gigantic(h))
Andi Kleenaa888a72008-07-23 21:27:47 -07002127 return;
2128
Lee Schermerhorn6ae11b22009-12-14 17:58:16 -08002129 for_each_node_mask(i, *nodes_allowed) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 struct page *page, *next;
Andi Kleena5516432008-07-23 21:27:41 -07002131 struct list_head *freel = &h->hugepage_freelists[i];
2132 list_for_each_entry_safe(page, next, freel, lru) {
2133 if (count >= h->nr_huge_pages)
Adam Litke6b0c8802007-10-16 01:26:23 -07002134 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 if (PageHighMem(page))
2136 continue;
2137 list_del(&page->lru);
Andi Kleene5ff2152008-07-23 21:27:42 -07002138 update_and_free_page(h, page);
Andi Kleena5516432008-07-23 21:27:41 -07002139 h->free_huge_pages--;
2140 h->free_huge_pages_node[page_to_nid(page)]--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 }
2142 }
2143}
2144#else
Lee Schermerhorn6ae11b22009-12-14 17:58:16 -08002145static inline void try_to_free_low(struct hstate *h, unsigned long count,
2146 nodemask_t *nodes_allowed)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147{
2148}
2149#endif
2150
Wu Fengguang20a03072009-06-16 15:32:22 -07002151/*
2152 * Increment or decrement surplus_huge_pages. Keep node-specific counters
2153 * balanced by operating on them in a round-robin fashion.
2154 * Returns 1 if an adjustment was made.
2155 */
Lee Schermerhorn6ae11b22009-12-14 17:58:16 -08002156static int adjust_pool_surplus(struct hstate *h, nodemask_t *nodes_allowed,
2157 int delta)
Wu Fengguang20a03072009-06-16 15:32:22 -07002158{
Joonsoo Kimb2261022013-09-11 14:21:00 -07002159 int nr_nodes, node;
Wu Fengguang20a03072009-06-16 15:32:22 -07002160
2161 VM_BUG_ON(delta != -1 && delta != 1);
Wu Fengguang20a03072009-06-16 15:32:22 -07002162
Joonsoo Kimb2261022013-09-11 14:21:00 -07002163 if (delta < 0) {
2164 for_each_node_mask_to_alloc(h, nr_nodes, node, nodes_allowed) {
2165 if (h->surplus_huge_pages_node[node])
2166 goto found;
Lee Schermerhorne8c5c822009-09-21 17:01:22 -07002167 }
Joonsoo Kimb2261022013-09-11 14:21:00 -07002168 } else {
2169 for_each_node_mask_to_free(h, nr_nodes, node, nodes_allowed) {
2170 if (h->surplus_huge_pages_node[node] <
2171 h->nr_huge_pages_node[node])
2172 goto found;
Lee Schermerhorne8c5c822009-09-21 17:01:22 -07002173 }
Joonsoo Kimb2261022013-09-11 14:21:00 -07002174 }
2175 return 0;
Wu Fengguang20a03072009-06-16 15:32:22 -07002176
Joonsoo Kimb2261022013-09-11 14:21:00 -07002177found:
2178 h->surplus_huge_pages += delta;
2179 h->surplus_huge_pages_node[node] += delta;
2180 return 1;
Wu Fengguang20a03072009-06-16 15:32:22 -07002181}
2182
Andi Kleena5516432008-07-23 21:27:41 -07002183#define persistent_huge_pages(h) (h->nr_huge_pages - h->surplus_huge_pages)
Lee Schermerhorn6ae11b22009-12-14 17:58:16 -08002184static unsigned long set_max_huge_pages(struct hstate *h, unsigned long count,
2185 nodemask_t *nodes_allowed)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186{
Adam Litke7893d1d2007-10-16 01:26:18 -07002187 unsigned long min_count, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07002189 if (hstate_is_gigantic(h) && !gigantic_page_supported())
Andi Kleenaa888a72008-07-23 21:27:47 -07002190 return h->max_huge_pages;
2191
Adam Litke7893d1d2007-10-16 01:26:18 -07002192 /*
2193 * Increase the pool size
2194 * First take pages out of surplus state. Then make up the
2195 * remaining difference by allocating fresh huge pages.
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08002196 *
Naoya Horiguchid15c7c02015-11-10 14:45:11 -08002197 * We might race with __alloc_buddy_huge_page() here and be unable
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08002198 * to convert a surplus huge page to a normal huge page. That is
2199 * not critical, though, it just means the overall size of the
2200 * pool might be one hugepage larger than it needs to be, but
2201 * within all the constraints specified by the sysctls.
Adam Litke7893d1d2007-10-16 01:26:18 -07002202 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203 spin_lock(&hugetlb_lock);
Andi Kleena5516432008-07-23 21:27:41 -07002204 while (h->surplus_huge_pages && count > persistent_huge_pages(h)) {
Lee Schermerhorn6ae11b22009-12-14 17:58:16 -08002205 if (!adjust_pool_surplus(h, nodes_allowed, -1))
Adam Litke7893d1d2007-10-16 01:26:18 -07002206 break;
2207 }
2208
Andi Kleena5516432008-07-23 21:27:41 -07002209 while (count > persistent_huge_pages(h)) {
Adam Litke7893d1d2007-10-16 01:26:18 -07002210 /*
2211 * If this allocation races such that we no longer need the
2212 * page, free_huge_page will handle it by freeing the page
2213 * and reducing the surplus.
2214 */
2215 spin_unlock(&hugetlb_lock);
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07002216 if (hstate_is_gigantic(h))
2217 ret = alloc_fresh_gigantic_page(h, nodes_allowed);
2218 else
2219 ret = alloc_fresh_huge_page(h, nodes_allowed);
Adam Litke7893d1d2007-10-16 01:26:18 -07002220 spin_lock(&hugetlb_lock);
2221 if (!ret)
2222 goto out;
2223
Mel Gorman536240f22009-12-14 17:59:56 -08002224 /* Bail for signals. Probably ctrl-c from user */
2225 if (signal_pending(current))
2226 goto out;
Adam Litke7893d1d2007-10-16 01:26:18 -07002227 }
Adam Litke7893d1d2007-10-16 01:26:18 -07002228
2229 /*
2230 * Decrease the pool size
2231 * First return free pages to the buddy allocator (being careful
2232 * to keep enough around to satisfy reservations). Then place
2233 * pages into surplus state as needed so the pool will shrink
2234 * to the desired size as pages become free.
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08002235 *
2236 * By placing pages into the surplus state independent of the
2237 * overcommit value, we are allowing the surplus pool size to
2238 * exceed overcommit. There are few sane options here. Since
Naoya Horiguchid15c7c02015-11-10 14:45:11 -08002239 * __alloc_buddy_huge_page() is checking the global counter,
Nishanth Aravamudand1c3fb12007-12-17 16:20:12 -08002240 * though, we'll note that we're not allowed to exceed surplus
2241 * and won't grow the pool anywhere else. Not until one of the
2242 * sysctls are changed, or the surplus pages go out of use.
Adam Litke7893d1d2007-10-16 01:26:18 -07002243 */
Andi Kleena5516432008-07-23 21:27:41 -07002244 min_count = h->resv_huge_pages + h->nr_huge_pages - h->free_huge_pages;
Adam Litke6b0c8802007-10-16 01:26:23 -07002245 min_count = max(count, min_count);
Lee Schermerhorn6ae11b22009-12-14 17:58:16 -08002246 try_to_free_low(h, min_count, nodes_allowed);
Andi Kleena5516432008-07-23 21:27:41 -07002247 while (min_count < persistent_huge_pages(h)) {
Lee Schermerhorn6ae11b22009-12-14 17:58:16 -08002248 if (!free_pool_huge_page(h, nodes_allowed, 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 break;
Mizuma, Masayoshi55f67142014-04-07 15:37:54 -07002250 cond_resched_lock(&hugetlb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 }
Andi Kleena5516432008-07-23 21:27:41 -07002252 while (count < persistent_huge_pages(h)) {
Lee Schermerhorn6ae11b22009-12-14 17:58:16 -08002253 if (!adjust_pool_surplus(h, nodes_allowed, 1))
Adam Litke7893d1d2007-10-16 01:26:18 -07002254 break;
2255 }
2256out:
Andi Kleena5516432008-07-23 21:27:41 -07002257 ret = persistent_huge_pages(h);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258 spin_unlock(&hugetlb_lock);
Adam Litke7893d1d2007-10-16 01:26:18 -07002259 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260}
2261
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002262#define HSTATE_ATTR_RO(_name) \
2263 static struct kobj_attribute _name##_attr = __ATTR_RO(_name)
2264
2265#define HSTATE_ATTR(_name) \
2266 static struct kobj_attribute _name##_attr = \
2267 __ATTR(_name, 0644, _name##_show, _name##_store)
2268
2269static struct kobject *hugepages_kobj;
2270static struct kobject *hstate_kobjs[HUGE_MAX_HSTATE];
2271
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002272static struct hstate *kobj_to_node_hstate(struct kobject *kobj, int *nidp);
2273
2274static struct hstate *kobj_to_hstate(struct kobject *kobj, int *nidp)
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002275{
2276 int i;
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002277
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002278 for (i = 0; i < HUGE_MAX_HSTATE; i++)
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002279 if (hstate_kobjs[i] == kobj) {
2280 if (nidp)
2281 *nidp = NUMA_NO_NODE;
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002282 return &hstates[i];
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002283 }
2284
2285 return kobj_to_node_hstate(kobj, nidp);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002286}
2287
Lee Schermerhorn06808b02009-12-14 17:58:21 -08002288static ssize_t nr_hugepages_show_common(struct kobject *kobj,
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002289 struct kobj_attribute *attr, char *buf)
2290{
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002291 struct hstate *h;
2292 unsigned long nr_huge_pages;
2293 int nid;
2294
2295 h = kobj_to_hstate(kobj, &nid);
2296 if (nid == NUMA_NO_NODE)
2297 nr_huge_pages = h->nr_huge_pages;
2298 else
2299 nr_huge_pages = h->nr_huge_pages_node[nid];
2300
2301 return sprintf(buf, "%lu\n", nr_huge_pages);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002302}
Eric B Munsonadbe8722011-01-13 15:47:27 -08002303
David Rientjes238d3c12014-08-06 16:06:51 -07002304static ssize_t __nr_hugepages_store_common(bool obey_mempolicy,
2305 struct hstate *h, int nid,
2306 unsigned long count, size_t len)
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002307{
2308 int err;
David Rientjesbad44b52009-12-14 17:58:38 -08002309 NODEMASK_ALLOC(nodemask_t, nodes_allowed, GFP_KERNEL | __GFP_NORETRY);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002310
Luiz Capitulino944d9fe2014-06-04 16:07:13 -07002311 if (hstate_is_gigantic(h) && !gigantic_page_supported()) {
Eric B Munsonadbe8722011-01-13 15:47:27 -08002312 err = -EINVAL;
2313 goto out;
2314 }
2315
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002316 if (nid == NUMA_NO_NODE) {
2317 /*
2318 * global hstate attribute
2319 */
2320 if (!(obey_mempolicy &&
2321 init_nodemask_of_mempolicy(nodes_allowed))) {
2322 NODEMASK_FREE(nodes_allowed);
Lai Jiangshan8cebfcd2012-12-12 13:51:36 -08002323 nodes_allowed = &node_states[N_MEMORY];
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002324 }
2325 } else if (nodes_allowed) {
2326 /*
2327 * per node hstate attribute: adjust count to global,
2328 * but restrict alloc/free to the specified node.
2329 */
2330 count += h->nr_huge_pages - h->nr_huge_pages_node[nid];
2331 init_nodemask_of_node(nodes_allowed, nid);
2332 } else
Lai Jiangshan8cebfcd2012-12-12 13:51:36 -08002333 nodes_allowed = &node_states[N_MEMORY];
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002334
Lee Schermerhorn06808b02009-12-14 17:58:21 -08002335 h->max_huge_pages = set_max_huge_pages(h, count, nodes_allowed);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002336
Lai Jiangshan8cebfcd2012-12-12 13:51:36 -08002337 if (nodes_allowed != &node_states[N_MEMORY])
Lee Schermerhorn06808b02009-12-14 17:58:21 -08002338 NODEMASK_FREE(nodes_allowed);
2339
2340 return len;
Eric B Munsonadbe8722011-01-13 15:47:27 -08002341out:
2342 NODEMASK_FREE(nodes_allowed);
2343 return err;
Lee Schermerhorn06808b02009-12-14 17:58:21 -08002344}
2345
David Rientjes238d3c12014-08-06 16:06:51 -07002346static ssize_t nr_hugepages_store_common(bool obey_mempolicy,
2347 struct kobject *kobj, const char *buf,
2348 size_t len)
2349{
2350 struct hstate *h;
2351 unsigned long count;
2352 int nid;
2353 int err;
2354
2355 err = kstrtoul(buf, 10, &count);
2356 if (err)
2357 return err;
2358
2359 h = kobj_to_hstate(kobj, &nid);
2360 return __nr_hugepages_store_common(obey_mempolicy, h, nid, count, len);
2361}
2362
Lee Schermerhorn06808b02009-12-14 17:58:21 -08002363static ssize_t nr_hugepages_show(struct kobject *kobj,
2364 struct kobj_attribute *attr, char *buf)
2365{
2366 return nr_hugepages_show_common(kobj, attr, buf);
2367}
2368
2369static ssize_t nr_hugepages_store(struct kobject *kobj,
2370 struct kobj_attribute *attr, const char *buf, size_t len)
2371{
David Rientjes238d3c12014-08-06 16:06:51 -07002372 return nr_hugepages_store_common(false, kobj, buf, len);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002373}
2374HSTATE_ATTR(nr_hugepages);
2375
Lee Schermerhorn06808b02009-12-14 17:58:21 -08002376#ifdef CONFIG_NUMA
2377
2378/*
2379 * hstate attribute for optionally mempolicy-based constraint on persistent
2380 * huge page alloc/free.
2381 */
2382static ssize_t nr_hugepages_mempolicy_show(struct kobject *kobj,
2383 struct kobj_attribute *attr, char *buf)
2384{
2385 return nr_hugepages_show_common(kobj, attr, buf);
2386}
2387
2388static ssize_t nr_hugepages_mempolicy_store(struct kobject *kobj,
2389 struct kobj_attribute *attr, const char *buf, size_t len)
2390{
David Rientjes238d3c12014-08-06 16:06:51 -07002391 return nr_hugepages_store_common(true, kobj, buf, len);
Lee Schermerhorn06808b02009-12-14 17:58:21 -08002392}
2393HSTATE_ATTR(nr_hugepages_mempolicy);
2394#endif
2395
2396
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002397static ssize_t nr_overcommit_hugepages_show(struct kobject *kobj,
2398 struct kobj_attribute *attr, char *buf)
2399{
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002400 struct hstate *h = kobj_to_hstate(kobj, NULL);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002401 return sprintf(buf, "%lu\n", h->nr_overcommit_huge_pages);
2402}
Eric B Munsonadbe8722011-01-13 15:47:27 -08002403
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002404static ssize_t nr_overcommit_hugepages_store(struct kobject *kobj,
2405 struct kobj_attribute *attr, const char *buf, size_t count)
2406{
2407 int err;
2408 unsigned long input;
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002409 struct hstate *h = kobj_to_hstate(kobj, NULL);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002410
Luiz Capitulinobae7f4a2014-06-04 16:07:08 -07002411 if (hstate_is_gigantic(h))
Eric B Munsonadbe8722011-01-13 15:47:27 -08002412 return -EINVAL;
2413
Jingoo Han3dbb95f2013-09-11 14:20:25 -07002414 err = kstrtoul(buf, 10, &input);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002415 if (err)
Eric B Munson73ae31e2011-01-13 15:47:28 -08002416 return err;
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002417
2418 spin_lock(&hugetlb_lock);
2419 h->nr_overcommit_huge_pages = input;
2420 spin_unlock(&hugetlb_lock);
2421
2422 return count;
2423}
2424HSTATE_ATTR(nr_overcommit_hugepages);
2425
2426static ssize_t free_hugepages_show(struct kobject *kobj,
2427 struct kobj_attribute *attr, char *buf)
2428{
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002429 struct hstate *h;
2430 unsigned long free_huge_pages;
2431 int nid;
2432
2433 h = kobj_to_hstate(kobj, &nid);
2434 if (nid == NUMA_NO_NODE)
2435 free_huge_pages = h->free_huge_pages;
2436 else
2437 free_huge_pages = h->free_huge_pages_node[nid];
2438
2439 return sprintf(buf, "%lu\n", free_huge_pages);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002440}
2441HSTATE_ATTR_RO(free_hugepages);
2442
2443static ssize_t resv_hugepages_show(struct kobject *kobj,
2444 struct kobj_attribute *attr, char *buf)
2445{
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002446 struct hstate *h = kobj_to_hstate(kobj, NULL);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002447 return sprintf(buf, "%lu\n", h->resv_huge_pages);
2448}
2449HSTATE_ATTR_RO(resv_hugepages);
2450
2451static ssize_t surplus_hugepages_show(struct kobject *kobj,
2452 struct kobj_attribute *attr, char *buf)
2453{
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002454 struct hstate *h;
2455 unsigned long surplus_huge_pages;
2456 int nid;
2457
2458 h = kobj_to_hstate(kobj, &nid);
2459 if (nid == NUMA_NO_NODE)
2460 surplus_huge_pages = h->surplus_huge_pages;
2461 else
2462 surplus_huge_pages = h->surplus_huge_pages_node[nid];
2463
2464 return sprintf(buf, "%lu\n", surplus_huge_pages);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002465}
2466HSTATE_ATTR_RO(surplus_hugepages);
2467
2468static struct attribute *hstate_attrs[] = {
2469 &nr_hugepages_attr.attr,
2470 &nr_overcommit_hugepages_attr.attr,
2471 &free_hugepages_attr.attr,
2472 &resv_hugepages_attr.attr,
2473 &surplus_hugepages_attr.attr,
Lee Schermerhorn06808b02009-12-14 17:58:21 -08002474#ifdef CONFIG_NUMA
2475 &nr_hugepages_mempolicy_attr.attr,
2476#endif
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002477 NULL,
2478};
2479
2480static struct attribute_group hstate_attr_group = {
2481 .attrs = hstate_attrs,
2482};
2483
Jeff Mahoney094e9532010-02-02 13:44:14 -08002484static int hugetlb_sysfs_add_hstate(struct hstate *h, struct kobject *parent,
2485 struct kobject **hstate_kobjs,
2486 struct attribute_group *hstate_attr_group)
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002487{
2488 int retval;
Aneesh Kumar K.V972dc4d2012-07-31 16:42:00 -07002489 int hi = hstate_index(h);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002490
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002491 hstate_kobjs[hi] = kobject_create_and_add(h->name, parent);
2492 if (!hstate_kobjs[hi])
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002493 return -ENOMEM;
2494
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002495 retval = sysfs_create_group(hstate_kobjs[hi], hstate_attr_group);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002496 if (retval)
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002497 kobject_put(hstate_kobjs[hi]);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002498
2499 return retval;
2500}
2501
2502static void __init hugetlb_sysfs_init(void)
2503{
2504 struct hstate *h;
2505 int err;
2506
2507 hugepages_kobj = kobject_create_and_add("hugepages", mm_kobj);
2508 if (!hugepages_kobj)
2509 return;
2510
2511 for_each_hstate(h) {
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002512 err = hugetlb_sysfs_add_hstate(h, hugepages_kobj,
2513 hstate_kobjs, &hstate_attr_group);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002514 if (err)
Andrew Mortonffb22af2013-02-22 16:32:08 -08002515 pr_err("Hugetlb: Unable to add hstate %s", h->name);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002516 }
2517}
2518
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002519#ifdef CONFIG_NUMA
2520
2521/*
2522 * node_hstate/s - associate per node hstate attributes, via their kobjects,
Kay Sievers10fbcf42011-12-21 14:48:43 -08002523 * with node devices in node_devices[] using a parallel array. The array
2524 * index of a node device or _hstate == node id.
2525 * This is here to avoid any static dependency of the node device driver, in
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002526 * the base kernel, on the hugetlb module.
2527 */
2528struct node_hstate {
2529 struct kobject *hugepages_kobj;
2530 struct kobject *hstate_kobjs[HUGE_MAX_HSTATE];
2531};
Alexander Kuleshovb4e289a2015-11-05 18:50:14 -08002532static struct node_hstate node_hstates[MAX_NUMNODES];
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002533
2534/*
Kay Sievers10fbcf42011-12-21 14:48:43 -08002535 * A subset of global hstate attributes for node devices
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002536 */
2537static struct attribute *per_node_hstate_attrs[] = {
2538 &nr_hugepages_attr.attr,
2539 &free_hugepages_attr.attr,
2540 &surplus_hugepages_attr.attr,
2541 NULL,
2542};
2543
2544static struct attribute_group per_node_hstate_attr_group = {
2545 .attrs = per_node_hstate_attrs,
2546};
2547
2548/*
Kay Sievers10fbcf42011-12-21 14:48:43 -08002549 * kobj_to_node_hstate - lookup global hstate for node device hstate attr kobj.
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002550 * Returns node id via non-NULL nidp.
2551 */
2552static struct hstate *kobj_to_node_hstate(struct kobject *kobj, int *nidp)
2553{
2554 int nid;
2555
2556 for (nid = 0; nid < nr_node_ids; nid++) {
2557 struct node_hstate *nhs = &node_hstates[nid];
2558 int i;
2559 for (i = 0; i < HUGE_MAX_HSTATE; i++)
2560 if (nhs->hstate_kobjs[i] == kobj) {
2561 if (nidp)
2562 *nidp = nid;
2563 return &hstates[i];
2564 }
2565 }
2566
2567 BUG();
2568 return NULL;
2569}
2570
2571/*
Kay Sievers10fbcf42011-12-21 14:48:43 -08002572 * Unregister hstate attributes from a single node device.
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002573 * No-op if no hstate attributes attached.
2574 */
Claudiu Ghioc3cd8b442013-03-04 12:46:15 +02002575static void hugetlb_unregister_node(struct node *node)
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002576{
2577 struct hstate *h;
Kay Sievers10fbcf42011-12-21 14:48:43 -08002578 struct node_hstate *nhs = &node_hstates[node->dev.id];
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002579
2580 if (!nhs->hugepages_kobj)
Lee Schermerhorn9b5e5d02009-12-14 17:58:32 -08002581 return; /* no hstate attributes */
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002582
Aneesh Kumar K.V972dc4d2012-07-31 16:42:00 -07002583 for_each_hstate(h) {
2584 int idx = hstate_index(h);
2585 if (nhs->hstate_kobjs[idx]) {
2586 kobject_put(nhs->hstate_kobjs[idx]);
2587 nhs->hstate_kobjs[idx] = NULL;
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002588 }
Aneesh Kumar K.V972dc4d2012-07-31 16:42:00 -07002589 }
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002590
2591 kobject_put(nhs->hugepages_kobj);
2592 nhs->hugepages_kobj = NULL;
2593}
2594
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002595
2596/*
Kay Sievers10fbcf42011-12-21 14:48:43 -08002597 * Register hstate attributes for a single node device.
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002598 * No-op if attributes already registered.
2599 */
Claudiu Ghioc3cd8b442013-03-04 12:46:15 +02002600static void hugetlb_register_node(struct node *node)
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002601{
2602 struct hstate *h;
Kay Sievers10fbcf42011-12-21 14:48:43 -08002603 struct node_hstate *nhs = &node_hstates[node->dev.id];
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002604 int err;
2605
2606 if (nhs->hugepages_kobj)
2607 return; /* already allocated */
2608
2609 nhs->hugepages_kobj = kobject_create_and_add("hugepages",
Kay Sievers10fbcf42011-12-21 14:48:43 -08002610 &node->dev.kobj);
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002611 if (!nhs->hugepages_kobj)
2612 return;
2613
2614 for_each_hstate(h) {
2615 err = hugetlb_sysfs_add_hstate(h, nhs->hugepages_kobj,
2616 nhs->hstate_kobjs,
2617 &per_node_hstate_attr_group);
2618 if (err) {
Andrew Mortonffb22af2013-02-22 16:32:08 -08002619 pr_err("Hugetlb: Unable to add hstate %s for node %d\n",
2620 h->name, node->dev.id);
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002621 hugetlb_unregister_node(node);
2622 break;
2623 }
2624 }
2625}
2626
2627/*
Lee Schermerhorn9b5e5d02009-12-14 17:58:32 -08002628 * hugetlb init time: register hstate attributes for all registered node
Kay Sievers10fbcf42011-12-21 14:48:43 -08002629 * devices of nodes that have memory. All on-line nodes should have
2630 * registered their associated device by this time.
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002631 */
Luiz Capitulino7d9ca002014-12-12 16:55:24 -08002632static void __init hugetlb_register_all_nodes(void)
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002633{
2634 int nid;
2635
Lai Jiangshan8cebfcd2012-12-12 13:51:36 -08002636 for_each_node_state(nid, N_MEMORY) {
Wen Congyang87327942012-12-11 16:00:56 -08002637 struct node *node = node_devices[nid];
Kay Sievers10fbcf42011-12-21 14:48:43 -08002638 if (node->dev.id == nid)
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002639 hugetlb_register_node(node);
2640 }
2641
2642 /*
Kay Sievers10fbcf42011-12-21 14:48:43 -08002643 * Let the node device driver know we're here so it can
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002644 * [un]register hstate attributes on node hotplug.
2645 */
2646 register_hugetlbfs_with_node(hugetlb_register_node,
2647 hugetlb_unregister_node);
2648}
2649#else /* !CONFIG_NUMA */
2650
2651static struct hstate *kobj_to_node_hstate(struct kobject *kobj, int *nidp)
2652{
2653 BUG();
2654 if (nidp)
2655 *nidp = -1;
2656 return NULL;
2657}
2658
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002659static void hugetlb_register_all_nodes(void) { }
2660
2661#endif
2662
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002663static int __init hugetlb_init(void)
2664{
Davidlohr Bueso8382d912014-04-03 14:47:31 -07002665 int i;
2666
Nishanth Aravamudan457c1b22014-05-06 12:50:00 -07002667 if (!hugepages_supported())
Benjamin Herrenschmidt0ef89d22008-07-31 00:07:30 -07002668 return 0;
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002669
Nick Piggine11bfbf2008-07-23 21:27:52 -07002670 if (!size_to_hstate(default_hstate_size)) {
2671 default_hstate_size = HPAGE_SIZE;
2672 if (!size_to_hstate(default_hstate_size))
2673 hugetlb_add_hstate(HUGETLB_PAGE_ORDER);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002674 }
Aneesh Kumar K.V972dc4d2012-07-31 16:42:00 -07002675 default_hstate_idx = hstate_index(size_to_hstate(default_hstate_size));
Vaishali Thakkarf8b74812016-02-17 13:11:26 -08002676 if (default_hstate_max_huge_pages) {
2677 if (!default_hstate.max_huge_pages)
2678 default_hstate.max_huge_pages = default_hstate_max_huge_pages;
2679 }
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002680
2681 hugetlb_init_hstates();
Andi Kleenaa888a72008-07-23 21:27:47 -07002682 gather_bootmem_prealloc();
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002683 report_hugepages();
2684
2685 hugetlb_sysfs_init();
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002686 hugetlb_register_all_nodes();
Jianguo Wu7179e7b2012-12-18 14:23:19 -08002687 hugetlb_cgroup_file_init();
Lee Schermerhorn9a3052302009-12-14 17:58:25 -08002688
Davidlohr Bueso8382d912014-04-03 14:47:31 -07002689#ifdef CONFIG_SMP
2690 num_fault_mutexes = roundup_pow_of_two(8 * num_possible_cpus());
2691#else
2692 num_fault_mutexes = 1;
2693#endif
Mike Kravetzc672c7f2015-09-08 15:01:35 -07002694 hugetlb_fault_mutex_table =
Davidlohr Bueso8382d912014-04-03 14:47:31 -07002695 kmalloc(sizeof(struct mutex) * num_fault_mutexes, GFP_KERNEL);
Mike Kravetzc672c7f2015-09-08 15:01:35 -07002696 BUG_ON(!hugetlb_fault_mutex_table);
Davidlohr Bueso8382d912014-04-03 14:47:31 -07002697
2698 for (i = 0; i < num_fault_mutexes; i++)
Mike Kravetzc672c7f2015-09-08 15:01:35 -07002699 mutex_init(&hugetlb_fault_mutex_table[i]);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002700 return 0;
2701}
Paul Gortmaker3e89e1c2016-01-14 15:21:52 -08002702subsys_initcall(hugetlb_init);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002703
2704/* Should be called on processing a hugepagesz=... option */
Vaishali Thakkar9fee0212016-05-19 17:11:04 -07002705void __init hugetlb_bad_size(void)
2706{
2707 parsed_valid_hugepagesz = false;
2708}
2709
Kirill A. Shutemovd00181b2015-11-06 16:29:57 -08002710void __init hugetlb_add_hstate(unsigned int order)
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002711{
2712 struct hstate *h;
Andi Kleen8faa8b02008-07-23 21:27:48 -07002713 unsigned long i;
2714
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002715 if (size_to_hstate(PAGE_SIZE << order)) {
Joe Perches598d8092016-03-17 14:19:44 -07002716 pr_warn("hugepagesz= specified twice, ignoring\n");
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002717 return;
2718 }
Aneesh Kumar K.V47d38342012-07-31 16:41:54 -07002719 BUG_ON(hugetlb_max_hstate >= HUGE_MAX_HSTATE);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002720 BUG_ON(order == 0);
Aneesh Kumar K.V47d38342012-07-31 16:41:54 -07002721 h = &hstates[hugetlb_max_hstate++];
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002722 h->order = order;
2723 h->mask = ~((1ULL << (order + PAGE_SHIFT)) - 1);
Andi Kleen8faa8b02008-07-23 21:27:48 -07002724 h->nr_huge_pages = 0;
2725 h->free_huge_pages = 0;
2726 for (i = 0; i < MAX_NUMNODES; ++i)
2727 INIT_LIST_HEAD(&h->hugepage_freelists[i]);
Aneesh Kumar K.V0edaecf2012-07-31 16:42:07 -07002728 INIT_LIST_HEAD(&h->hugepage_activelist);
Andrew Morton54f18d32016-05-19 17:11:40 -07002729 h->next_nid_to_alloc = first_memory_node;
2730 h->next_nid_to_free = first_memory_node;
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002731 snprintf(h->name, HSTATE_NAME_LEN, "hugepages-%lukB",
2732 huge_page_size(h)/1024);
Andi Kleen8faa8b02008-07-23 21:27:48 -07002733
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002734 parsed_hstate = h;
2735}
2736
Nick Piggine11bfbf2008-07-23 21:27:52 -07002737static int __init hugetlb_nrpages_setup(char *s)
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002738{
2739 unsigned long *mhp;
Andi Kleen8faa8b02008-07-23 21:27:48 -07002740 static unsigned long *last_mhp;
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002741
Vaishali Thakkar9fee0212016-05-19 17:11:04 -07002742 if (!parsed_valid_hugepagesz) {
2743 pr_warn("hugepages = %s preceded by "
2744 "an unsupported hugepagesz, ignoring\n", s);
2745 parsed_valid_hugepagesz = true;
2746 return 1;
2747 }
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002748 /*
Aneesh Kumar K.V47d38342012-07-31 16:41:54 -07002749 * !hugetlb_max_hstate means we haven't parsed a hugepagesz= parameter yet,
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002750 * so this hugepages= parameter goes to the "default hstate".
2751 */
Vaishali Thakkar9fee0212016-05-19 17:11:04 -07002752 else if (!hugetlb_max_hstate)
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002753 mhp = &default_hstate_max_huge_pages;
2754 else
2755 mhp = &parsed_hstate->max_huge_pages;
2756
Andi Kleen8faa8b02008-07-23 21:27:48 -07002757 if (mhp == last_mhp) {
Joe Perches598d8092016-03-17 14:19:44 -07002758 pr_warn("hugepages= specified twice without interleaving hugepagesz=, ignoring\n");
Andi Kleen8faa8b02008-07-23 21:27:48 -07002759 return 1;
2760 }
2761
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002762 if (sscanf(s, "%lu", mhp) <= 0)
2763 *mhp = 0;
2764
Andi Kleen8faa8b02008-07-23 21:27:48 -07002765 /*
2766 * Global state is always initialized later in hugetlb_init.
2767 * But we need to allocate >= MAX_ORDER hstates here early to still
2768 * use the bootmem allocator.
2769 */
Aneesh Kumar K.V47d38342012-07-31 16:41:54 -07002770 if (hugetlb_max_hstate && parsed_hstate->order >= MAX_ORDER)
Andi Kleen8faa8b02008-07-23 21:27:48 -07002771 hugetlb_hstate_alloc_pages(parsed_hstate);
2772
2773 last_mhp = mhp;
2774
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002775 return 1;
2776}
Nick Piggine11bfbf2008-07-23 21:27:52 -07002777__setup("hugepages=", hugetlb_nrpages_setup);
2778
2779static int __init hugetlb_default_setup(char *s)
2780{
2781 default_hstate_size = memparse(s, &s);
2782 return 1;
2783}
2784__setup("default_hugepagesz=", hugetlb_default_setup);
Nishanth Aravamudana3437872008-07-23 21:27:44 -07002785
Nishanth Aravamudan8a213462008-07-25 19:44:37 -07002786static unsigned int cpuset_mems_nr(unsigned int *array)
2787{
2788 int node;
2789 unsigned int nr = 0;
2790
2791 for_each_node_mask(node, cpuset_current_mems_allowed)
2792 nr += array[node];
2793
2794 return nr;
2795}
2796
2797#ifdef CONFIG_SYSCTL
Lee Schermerhorn06808b02009-12-14 17:58:21 -08002798static int hugetlb_sysctl_handler_common(bool obey_mempolicy,
2799 struct ctl_table *table, int write,
2800 void __user *buffer, size_t *length, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801{
Andi Kleene5ff2152008-07-23 21:27:42 -07002802 struct hstate *h = &default_hstate;
David Rientjes238d3c12014-08-06 16:06:51 -07002803 unsigned long tmp = h->max_huge_pages;
Michal Hocko08d4a242011-01-13 15:47:26 -08002804 int ret;
Andi Kleene5ff2152008-07-23 21:27:42 -07002805
Nishanth Aravamudan457c1b22014-05-06 12:50:00 -07002806 if (!hugepages_supported())
Jan Stancek86613622016-03-09 14:08:35 -08002807 return -EOPNOTSUPP;
Nishanth Aravamudan457c1b22014-05-06 12:50:00 -07002808
Andi Kleene5ff2152008-07-23 21:27:42 -07002809 table->data = &tmp;
2810 table->maxlen = sizeof(unsigned long);
Michal Hocko08d4a242011-01-13 15:47:26 -08002811 ret = proc_doulongvec_minmax(table, write, buffer, length, ppos);
2812 if (ret)
2813 goto out;
Andi Kleene5ff2152008-07-23 21:27:42 -07002814
David Rientjes238d3c12014-08-06 16:06:51 -07002815 if (write)
2816 ret = __nr_hugepages_store_common(obey_mempolicy, h,
2817 NUMA_NO_NODE, tmp, *length);
Michal Hocko08d4a242011-01-13 15:47:26 -08002818out:
2819 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820}
Mel Gorman396faf02007-07-17 04:03:13 -07002821
Lee Schermerhorn06808b02009-12-14 17:58:21 -08002822int hugetlb_sysctl_handler(struct ctl_table *table, int write,
2823 void __user *buffer, size_t *length, loff_t *ppos)
2824{
2825
2826 return hugetlb_sysctl_handler_common(false, table, write,
2827 buffer, length, ppos);
2828}
2829
2830#ifdef CONFIG_NUMA
2831int hugetlb_mempolicy_sysctl_handler(struct ctl_table *table, int write,
2832 void __user *buffer, size_t *length, loff_t *ppos)
2833{
2834 return hugetlb_sysctl_handler_common(true, table, write,
2835 buffer, length, ppos);
2836}
2837#endif /* CONFIG_NUMA */
2838
Nishanth Aravamudana3d0c6a2008-02-08 04:18:18 -08002839int hugetlb_overcommit_handler(struct ctl_table *table, int write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07002840 void __user *buffer,
Nishanth Aravamudana3d0c6a2008-02-08 04:18:18 -08002841 size_t *length, loff_t *ppos)
2842{
Andi Kleena5516432008-07-23 21:27:41 -07002843 struct hstate *h = &default_hstate;
Andi Kleene5ff2152008-07-23 21:27:42 -07002844 unsigned long tmp;
Michal Hocko08d4a242011-01-13 15:47:26 -08002845 int ret;
Andi Kleene5ff2152008-07-23 21:27:42 -07002846
Nishanth Aravamudan457c1b22014-05-06 12:50:00 -07002847 if (!hugepages_supported())
Jan Stancek86613622016-03-09 14:08:35 -08002848 return -EOPNOTSUPP;
Nishanth Aravamudan457c1b22014-05-06 12:50:00 -07002849
Petr Holasekc033a932011-03-22 16:33:05 -07002850 tmp = h->nr_overcommit_huge_pages;
Andi Kleene5ff2152008-07-23 21:27:42 -07002851
Luiz Capitulinobae7f4a2014-06-04 16:07:08 -07002852 if (write && hstate_is_gigantic(h))
Eric B Munsonadbe8722011-01-13 15:47:27 -08002853 return -EINVAL;
2854
Andi Kleene5ff2152008-07-23 21:27:42 -07002855 table->data = &tmp;
2856 table->maxlen = sizeof(unsigned long);
Michal Hocko08d4a242011-01-13 15:47:26 -08002857 ret = proc_doulongvec_minmax(table, write, buffer, length, ppos);
2858 if (ret)
2859 goto out;
Andi Kleene5ff2152008-07-23 21:27:42 -07002860
2861 if (write) {
2862 spin_lock(&hugetlb_lock);
2863 h->nr_overcommit_huge_pages = tmp;
2864 spin_unlock(&hugetlb_lock);
2865 }
Michal Hocko08d4a242011-01-13 15:47:26 -08002866out:
2867 return ret;
Nishanth Aravamudana3d0c6a2008-02-08 04:18:18 -08002868}
2869
Linus Torvalds1da177e2005-04-16 15:20:36 -07002870#endif /* CONFIG_SYSCTL */
2871
Alexey Dobriyane1759c22008-10-15 23:50:22 +04002872void hugetlb_report_meminfo(struct seq_file *m)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873{
Andi Kleena5516432008-07-23 21:27:41 -07002874 struct hstate *h = &default_hstate;
Nishanth Aravamudan457c1b22014-05-06 12:50:00 -07002875 if (!hugepages_supported())
2876 return;
Alexey Dobriyane1759c22008-10-15 23:50:22 +04002877 seq_printf(m,
Rik van Riel4f98a2f2008-10-18 20:26:32 -07002878 "HugePages_Total: %5lu\n"
2879 "HugePages_Free: %5lu\n"
2880 "HugePages_Rsvd: %5lu\n"
2881 "HugePages_Surp: %5lu\n"
2882 "Hugepagesize: %8lu kB\n",
Andi Kleena5516432008-07-23 21:27:41 -07002883 h->nr_huge_pages,
2884 h->free_huge_pages,
2885 h->resv_huge_pages,
2886 h->surplus_huge_pages,
2887 1UL << (huge_page_order(h) + PAGE_SHIFT - 10));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002888}
2889
2890int hugetlb_report_node_meminfo(int nid, char *buf)
2891{
Andi Kleena5516432008-07-23 21:27:41 -07002892 struct hstate *h = &default_hstate;
Nishanth Aravamudan457c1b22014-05-06 12:50:00 -07002893 if (!hugepages_supported())
2894 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895 return sprintf(buf,
2896 "Node %d HugePages_Total: %5u\n"
Nishanth Aravamudana1de0912008-03-26 14:37:53 -07002897 "Node %d HugePages_Free: %5u\n"
2898 "Node %d HugePages_Surp: %5u\n",
Andi Kleena5516432008-07-23 21:27:41 -07002899 nid, h->nr_huge_pages_node[nid],
2900 nid, h->free_huge_pages_node[nid],
2901 nid, h->surplus_huge_pages_node[nid]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902}
2903
David Rientjes949f7ec2013-04-29 15:07:48 -07002904void hugetlb_show_meminfo(void)
2905{
2906 struct hstate *h;
2907 int nid;
2908
Nishanth Aravamudan457c1b22014-05-06 12:50:00 -07002909 if (!hugepages_supported())
2910 return;
2911
David Rientjes949f7ec2013-04-29 15:07:48 -07002912 for_each_node_state(nid, N_MEMORY)
2913 for_each_hstate(h)
2914 pr_info("Node %d hugepages_total=%u hugepages_free=%u hugepages_surp=%u hugepages_size=%lukB\n",
2915 nid,
2916 h->nr_huge_pages_node[nid],
2917 h->free_huge_pages_node[nid],
2918 h->surplus_huge_pages_node[nid],
2919 1UL << (huge_page_order(h) + PAGE_SHIFT - 10));
2920}
2921
Naoya Horiguchi5d317b22015-11-05 18:47:14 -08002922void hugetlb_report_usage(struct seq_file *m, struct mm_struct *mm)
2923{
2924 seq_printf(m, "HugetlbPages:\t%8lu kB\n",
2925 atomic_long_read(&mm->hugetlb_usage) << (PAGE_SHIFT - 10));
2926}
2927
Linus Torvalds1da177e2005-04-16 15:20:36 -07002928/* Return the number pages of memory we physically have, in PAGE_SIZE units. */
2929unsigned long hugetlb_total_pages(void)
2930{
Wanpeng Lid0028582013-03-22 15:04:40 -07002931 struct hstate *h;
2932 unsigned long nr_total_pages = 0;
2933
2934 for_each_hstate(h)
2935 nr_total_pages += h->nr_huge_pages * pages_per_huge_page(h);
2936 return nr_total_pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002938
Andi Kleena5516432008-07-23 21:27:41 -07002939static int hugetlb_acct_memory(struct hstate *h, long delta)
Mel Gormanfc1b8a72008-07-23 21:27:22 -07002940{
2941 int ret = -ENOMEM;
2942
2943 spin_lock(&hugetlb_lock);
2944 /*
2945 * When cpuset is configured, it breaks the strict hugetlb page
2946 * reservation as the accounting is done on a global variable. Such
2947 * reservation is completely rubbish in the presence of cpuset because
2948 * the reservation is not checked against page availability for the
2949 * current cpuset. Application can still potentially OOM'ed by kernel
2950 * with lack of free htlb page in cpuset that the task is in.
2951 * Attempt to enforce strict accounting with cpuset is almost
2952 * impossible (or too ugly) because cpuset is too fluid that
2953 * task or memory node can be dynamically moved between cpusets.
2954 *
2955 * The change of semantics for shared hugetlb mapping with cpuset is
2956 * undesirable. However, in order to preserve some of the semantics,
2957 * we fall back to check against current free page availability as
2958 * a best attempt and hopefully to minimize the impact of changing
2959 * semantics that cpuset has.
2960 */
2961 if (delta > 0) {
Andi Kleena5516432008-07-23 21:27:41 -07002962 if (gather_surplus_pages(h, delta) < 0)
Mel Gormanfc1b8a72008-07-23 21:27:22 -07002963 goto out;
2964
Andi Kleena5516432008-07-23 21:27:41 -07002965 if (delta > cpuset_mems_nr(h->free_huge_pages_node)) {
2966 return_unused_surplus_pages(h, delta);
Mel Gormanfc1b8a72008-07-23 21:27:22 -07002967 goto out;
2968 }
2969 }
2970
2971 ret = 0;
2972 if (delta < 0)
Andi Kleena5516432008-07-23 21:27:41 -07002973 return_unused_surplus_pages(h, (unsigned long) -delta);
Mel Gormanfc1b8a72008-07-23 21:27:22 -07002974
2975out:
2976 spin_unlock(&hugetlb_lock);
2977 return ret;
2978}
2979
Andy Whitcroft84afd992008-07-23 21:27:32 -07002980static void hugetlb_vm_op_open(struct vm_area_struct *vma)
2981{
Joonsoo Kimf522c3a2013-09-11 14:21:53 -07002982 struct resv_map *resv = vma_resv_map(vma);
Andy Whitcroft84afd992008-07-23 21:27:32 -07002983
2984 /*
2985 * This new VMA should share its siblings reservation map if present.
2986 * The VMA will only ever have a valid reservation map pointer where
2987 * it is being copied for another still existing VMA. As that VMA
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002988 * has a reference to the reservation map it cannot disappear until
Andy Whitcroft84afd992008-07-23 21:27:32 -07002989 * after this open call completes. It is therefore safe to take a
2990 * new reference here without additional locking.
2991 */
Joonsoo Kim4e35f482014-04-03 14:47:30 -07002992 if (resv && is_vma_resv_set(vma, HPAGE_RESV_OWNER))
Joonsoo Kimf522c3a2013-09-11 14:21:53 -07002993 kref_get(&resv->refs);
Andy Whitcroft84afd992008-07-23 21:27:32 -07002994}
2995
Mel Gormana1e78772008-07-23 21:27:23 -07002996static void hugetlb_vm_op_close(struct vm_area_struct *vma)
2997{
Andi Kleena5516432008-07-23 21:27:41 -07002998 struct hstate *h = hstate_vma(vma);
Joonsoo Kimf522c3a2013-09-11 14:21:53 -07002999 struct resv_map *resv = vma_resv_map(vma);
David Gibson90481622012-03-21 16:34:12 -07003000 struct hugepage_subpool *spool = subpool_vma(vma);
Joonsoo Kim4e35f482014-04-03 14:47:30 -07003001 unsigned long reserve, start, end;
Mike Kravetz1c5ecae2015-04-15 16:13:39 -07003002 long gbl_reserve;
Andy Whitcroft84afd992008-07-23 21:27:32 -07003003
Joonsoo Kim4e35f482014-04-03 14:47:30 -07003004 if (!resv || !is_vma_resv_set(vma, HPAGE_RESV_OWNER))
3005 return;
Andy Whitcroft84afd992008-07-23 21:27:32 -07003006
Joonsoo Kim4e35f482014-04-03 14:47:30 -07003007 start = vma_hugecache_offset(h, vma, vma->vm_start);
3008 end = vma_hugecache_offset(h, vma, vma->vm_end);
Andy Whitcroft84afd992008-07-23 21:27:32 -07003009
Joonsoo Kim4e35f482014-04-03 14:47:30 -07003010 reserve = (end - start) - region_count(resv, start, end);
Andy Whitcroft84afd992008-07-23 21:27:32 -07003011
Joonsoo Kim4e35f482014-04-03 14:47:30 -07003012 kref_put(&resv->refs, resv_map_release);
3013
3014 if (reserve) {
Mike Kravetz1c5ecae2015-04-15 16:13:39 -07003015 /*
3016 * Decrement reserve counts. The global reserve count may be
3017 * adjusted if the subpool has a minimum size.
3018 */
3019 gbl_reserve = hugepage_subpool_put_pages(spool, reserve);
3020 hugetlb_acct_memory(h, -gbl_reserve);
Andy Whitcroft84afd992008-07-23 21:27:32 -07003021 }
Mel Gormana1e78772008-07-23 21:27:23 -07003022}
3023
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024/*
3025 * We cannot handle pagefaults against hugetlb pages at all. They cause
3026 * handle_mm_fault() to try to instantiate regular-sized pages in the
3027 * hugegpage VMA. do_page_fault() is supposed to trap this, so BUG is we get
3028 * this far.
3029 */
Nick Piggind0217ac2007-07-19 01:47:03 -07003030static int hugetlb_vm_op_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031{
3032 BUG();
Nick Piggind0217ac2007-07-19 01:47:03 -07003033 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003034}
3035
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +04003036const struct vm_operations_struct hugetlb_vm_ops = {
Nick Piggind0217ac2007-07-19 01:47:03 -07003037 .fault = hugetlb_vm_op_fault,
Andy Whitcroft84afd992008-07-23 21:27:32 -07003038 .open = hugetlb_vm_op_open,
Mel Gormana1e78772008-07-23 21:27:23 -07003039 .close = hugetlb_vm_op_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040};
3041
David Gibson1e8f8892006-01-06 00:10:44 -08003042static pte_t make_huge_pte(struct vm_area_struct *vma, struct page *page,
3043 int writable)
David Gibson63551ae2005-06-21 17:14:44 -07003044{
3045 pte_t entry;
3046
David Gibson1e8f8892006-01-06 00:10:44 -08003047 if (writable) {
Gerald Schaefer106c9922013-04-29 15:07:23 -07003048 entry = huge_pte_mkwrite(huge_pte_mkdirty(mk_huge_pte(page,
3049 vma->vm_page_prot)));
David Gibson63551ae2005-06-21 17:14:44 -07003050 } else {
Gerald Schaefer106c9922013-04-29 15:07:23 -07003051 entry = huge_pte_wrprotect(mk_huge_pte(page,
3052 vma->vm_page_prot));
David Gibson63551ae2005-06-21 17:14:44 -07003053 }
3054 entry = pte_mkyoung(entry);
3055 entry = pte_mkhuge(entry);
Chris Metcalfd9ed9fa2012-04-01 14:01:34 -04003056 entry = arch_make_huge_pte(entry, vma, page, writable);
David Gibson63551ae2005-06-21 17:14:44 -07003057
3058 return entry;
3059}
3060
David Gibson1e8f8892006-01-06 00:10:44 -08003061static void set_huge_ptep_writable(struct vm_area_struct *vma,
3062 unsigned long address, pte_t *ptep)
3063{
3064 pte_t entry;
3065
Gerald Schaefer106c9922013-04-29 15:07:23 -07003066 entry = huge_pte_mkwrite(huge_pte_mkdirty(huge_ptep_get(ptep)));
Chris Forbes32f84522011-07-25 17:12:14 -07003067 if (huge_ptep_set_access_flags(vma, address, ptep, entry, 1))
Russell King4b3073e2009-12-18 16:40:18 +00003068 update_mmu_cache(vma, address, ptep);
David Gibson1e8f8892006-01-06 00:10:44 -08003069}
3070
Naoya Horiguchi4a705fe2014-06-23 13:22:03 -07003071static int is_hugetlb_entry_migration(pte_t pte)
3072{
3073 swp_entry_t swp;
3074
3075 if (huge_pte_none(pte) || pte_present(pte))
3076 return 0;
3077 swp = pte_to_swp_entry(pte);
3078 if (non_swap_entry(swp) && is_migration_entry(swp))
3079 return 1;
3080 else
3081 return 0;
3082}
3083
3084static int is_hugetlb_entry_hwpoisoned(pte_t pte)
3085{
3086 swp_entry_t swp;
3087
3088 if (huge_pte_none(pte) || pte_present(pte))
3089 return 0;
3090 swp = pte_to_swp_entry(pte);
3091 if (non_swap_entry(swp) && is_hwpoison_entry(swp))
3092 return 1;
3093 else
3094 return 0;
3095}
David Gibson1e8f8892006-01-06 00:10:44 -08003096
David Gibson63551ae2005-06-21 17:14:44 -07003097int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
3098 struct vm_area_struct *vma)
3099{
3100 pte_t *src_pte, *dst_pte, entry;
3101 struct page *ptepage;
Hugh Dickins1c598272005-10-19 21:23:43 -07003102 unsigned long addr;
David Gibson1e8f8892006-01-06 00:10:44 -08003103 int cow;
Andi Kleena5516432008-07-23 21:27:41 -07003104 struct hstate *h = hstate_vma(vma);
3105 unsigned long sz = huge_page_size(h);
Andreas Sandberge8569dd2014-01-21 15:49:09 -08003106 unsigned long mmun_start; /* For mmu_notifiers */
3107 unsigned long mmun_end; /* For mmu_notifiers */
3108 int ret = 0;
David Gibson1e8f8892006-01-06 00:10:44 -08003109
3110 cow = (vma->vm_flags & (VM_SHARED | VM_MAYWRITE)) == VM_MAYWRITE;
David Gibson63551ae2005-06-21 17:14:44 -07003111
Andreas Sandberge8569dd2014-01-21 15:49:09 -08003112 mmun_start = vma->vm_start;
3113 mmun_end = vma->vm_end;
3114 if (cow)
3115 mmu_notifier_invalidate_range_start(src, mmun_start, mmun_end);
3116
Andi Kleena5516432008-07-23 21:27:41 -07003117 for (addr = vma->vm_start; addr < vma->vm_end; addr += sz) {
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003118 spinlock_t *src_ptl, *dst_ptl;
Hugh Dickinsc74df322005-10-29 18:16:23 -07003119 src_pte = huge_pte_offset(src, addr);
3120 if (!src_pte)
3121 continue;
Andi Kleena5516432008-07-23 21:27:41 -07003122 dst_pte = huge_pte_alloc(dst, addr, sz);
Andreas Sandberge8569dd2014-01-21 15:49:09 -08003123 if (!dst_pte) {
3124 ret = -ENOMEM;
3125 break;
3126 }
Larry Woodmanc5c99422008-01-24 05:49:25 -08003127
3128 /* If the pagetables are shared don't copy or take references */
3129 if (dst_pte == src_pte)
3130 continue;
3131
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003132 dst_ptl = huge_pte_lock(h, dst, dst_pte);
3133 src_ptl = huge_pte_lockptr(h, src, src_pte);
3134 spin_lock_nested(src_ptl, SINGLE_DEPTH_NESTING);
Naoya Horiguchi4a705fe2014-06-23 13:22:03 -07003135 entry = huge_ptep_get(src_pte);
3136 if (huge_pte_none(entry)) { /* skip none entry */
3137 ;
3138 } else if (unlikely(is_hugetlb_entry_migration(entry) ||
3139 is_hugetlb_entry_hwpoisoned(entry))) {
3140 swp_entry_t swp_entry = pte_to_swp_entry(entry);
3141
3142 if (is_write_migration_entry(swp_entry) && cow) {
3143 /*
3144 * COW mappings require pages in both
3145 * parent and child to be set to read.
3146 */
3147 make_migration_entry_read(&swp_entry);
3148 entry = swp_entry_to_pte(swp_entry);
3149 set_huge_pte_at(src, addr, src_pte, entry);
3150 }
3151 set_huge_pte_at(dst, addr, dst_pte, entry);
3152 } else {
Joerg Roedel34ee6452014-11-13 13:46:09 +11003153 if (cow) {
Gerald Schaefer7f2e9522008-04-28 02:13:29 -07003154 huge_ptep_set_wrprotect(src, addr, src_pte);
Joerg Roedel34ee6452014-11-13 13:46:09 +11003155 mmu_notifier_invalidate_range(src, mmun_start,
3156 mmun_end);
3157 }
Naoya Horiguchi0253d632014-07-23 14:00:19 -07003158 entry = huge_ptep_get(src_pte);
Hugh Dickins1c598272005-10-19 21:23:43 -07003159 ptepage = pte_page(entry);
3160 get_page(ptepage);
Kirill A. Shutemov53f92632016-01-15 16:53:42 -08003161 page_dup_rmap(ptepage, true);
Hugh Dickins1c598272005-10-19 21:23:43 -07003162 set_huge_pte_at(dst, addr, dst_pte, entry);
Naoya Horiguchi5d317b22015-11-05 18:47:14 -08003163 hugetlb_count_add(pages_per_huge_page(h), dst);
Hugh Dickins1c598272005-10-19 21:23:43 -07003164 }
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003165 spin_unlock(src_ptl);
3166 spin_unlock(dst_ptl);
David Gibson63551ae2005-06-21 17:14:44 -07003167 }
David Gibson63551ae2005-06-21 17:14:44 -07003168
Andreas Sandberge8569dd2014-01-21 15:49:09 -08003169 if (cow)
3170 mmu_notifier_invalidate_range_end(src, mmun_start, mmun_end);
3171
3172 return ret;
David Gibson63551ae2005-06-21 17:14:44 -07003173}
3174
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -07003175void __unmap_hugepage_range(struct mmu_gather *tlb, struct vm_area_struct *vma,
3176 unsigned long start, unsigned long end,
3177 struct page *ref_page)
David Gibson63551ae2005-06-21 17:14:44 -07003178{
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -07003179 int force_flush = 0;
David Gibson63551ae2005-06-21 17:14:44 -07003180 struct mm_struct *mm = vma->vm_mm;
3181 unsigned long address;
David Gibsonc7546f82005-08-05 11:59:35 -07003182 pte_t *ptep;
David Gibson63551ae2005-06-21 17:14:44 -07003183 pte_t pte;
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003184 spinlock_t *ptl;
David Gibson63551ae2005-06-21 17:14:44 -07003185 struct page *page;
Andi Kleena5516432008-07-23 21:27:41 -07003186 struct hstate *h = hstate_vma(vma);
3187 unsigned long sz = huge_page_size(h);
Sagi Grimberg2ec74c32012-10-08 16:33:33 -07003188 const unsigned long mmun_start = start; /* For mmu_notifiers */
3189 const unsigned long mmun_end = end; /* For mmu_notifiers */
Andi Kleena5516432008-07-23 21:27:41 -07003190
David Gibson63551ae2005-06-21 17:14:44 -07003191 WARN_ON(!is_vm_hugetlb_page(vma));
Andi Kleena5516432008-07-23 21:27:41 -07003192 BUG_ON(start & ~huge_page_mask(h));
3193 BUG_ON(end & ~huge_page_mask(h));
David Gibson63551ae2005-06-21 17:14:44 -07003194
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -07003195 tlb_start_vma(tlb, vma);
Sagi Grimberg2ec74c32012-10-08 16:33:33 -07003196 mmu_notifier_invalidate_range_start(mm, mmun_start, mmun_end);
Hillf Danton569f48b82014-12-10 15:44:41 -08003197 address = start;
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -07003198again:
Hillf Danton569f48b82014-12-10 15:44:41 -08003199 for (; address < end; address += sz) {
David Gibsonc7546f82005-08-05 11:59:35 -07003200 ptep = huge_pte_offset(mm, address);
Adam Litke4c887262005-10-29 18:16:46 -07003201 if (!ptep)
David Gibsonc7546f82005-08-05 11:59:35 -07003202 continue;
3203
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003204 ptl = huge_pte_lock(h, mm, ptep);
Chen, Kenneth W39dde652006-12-06 20:32:03 -08003205 if (huge_pmd_unshare(mm, &address, ptep))
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003206 goto unlock;
Chen, Kenneth W39dde652006-12-06 20:32:03 -08003207
Hillf Danton66293262012-03-23 15:01:48 -07003208 pte = huge_ptep_get(ptep);
3209 if (huge_pte_none(pte))
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003210 goto unlock;
Hillf Danton66293262012-03-23 15:01:48 -07003211
3212 /*
Naoya Horiguchi9fbc1f62015-02-11 15:25:32 -08003213 * Migrating hugepage or HWPoisoned hugepage is already
3214 * unmapped and its refcount is dropped, so just clear pte here.
Hillf Danton66293262012-03-23 15:01:48 -07003215 */
Naoya Horiguchi9fbc1f62015-02-11 15:25:32 -08003216 if (unlikely(!pte_present(pte))) {
Gerald Schaefer106c9922013-04-29 15:07:23 -07003217 huge_pte_clear(mm, address, ptep);
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003218 goto unlock;
Naoya Horiguchi8c4894c2012-12-12 13:52:28 -08003219 }
Hillf Danton66293262012-03-23 15:01:48 -07003220
3221 page = pte_page(pte);
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003222 /*
3223 * If a reference page is supplied, it is because a specific
3224 * page is being unmapped, not a range. Ensure the page we
3225 * are about to unmap is the actual page of interest.
3226 */
3227 if (ref_page) {
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003228 if (page != ref_page)
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003229 goto unlock;
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003230
3231 /*
3232 * Mark the VMA as having unmapped its page so that
3233 * future faults in this VMA will fail rather than
3234 * looking like data was lost
3235 */
3236 set_vma_resv_flags(vma, HPAGE_RESV_UNMAPPED);
3237 }
3238
David Gibsonc7546f82005-08-05 11:59:35 -07003239 pte = huge_ptep_get_and_clear(mm, address, ptep);
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -07003240 tlb_remove_tlb_entry(tlb, ptep, address);
Gerald Schaefer106c9922013-04-29 15:07:23 -07003241 if (huge_pte_dirty(pte))
Ken Chen6649a382007-02-08 14:20:27 -08003242 set_page_dirty(page);
Hillf Danton9e811302012-03-21 16:34:03 -07003243
Naoya Horiguchi5d317b22015-11-05 18:47:14 -08003244 hugetlb_count_sub(pages_per_huge_page(h), mm);
Kirill A. Shutemovd281ee62016-01-15 16:52:16 -08003245 page_remove_rmap(page, true);
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -07003246 force_flush = !__tlb_remove_page(tlb, page);
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003247 if (force_flush) {
Hillf Danton569f48b82014-12-10 15:44:41 -08003248 address += sz;
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003249 spin_unlock(ptl);
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -07003250 break;
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003251 }
Hillf Danton9e811302012-03-21 16:34:03 -07003252 /* Bail out after unmapping reference page if supplied */
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003253 if (ref_page) {
3254 spin_unlock(ptl);
Hillf Danton9e811302012-03-21 16:34:03 -07003255 break;
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003256 }
3257unlock:
3258 spin_unlock(ptl);
David Gibson63551ae2005-06-21 17:14:44 -07003259 }
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -07003260 /*
3261 * mmu_gather ran out of room to batch pages, we break out of
3262 * the PTE lock to avoid doing the potential expensive TLB invalidate
3263 * and page-free while holding it.
3264 */
3265 if (force_flush) {
3266 force_flush = 0;
3267 tlb_flush_mmu(tlb);
3268 if (address < end && !ref_page)
3269 goto again;
Chen, Kenneth Wfe1668a2006-10-04 02:15:24 -07003270 }
Sagi Grimberg2ec74c32012-10-08 16:33:33 -07003271 mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end);
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -07003272 tlb_end_vma(tlb, vma);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003273}
David Gibson63551ae2005-06-21 17:14:44 -07003274
Mel Gormand8333522012-07-31 16:46:20 -07003275void __unmap_hugepage_range_final(struct mmu_gather *tlb,
3276 struct vm_area_struct *vma, unsigned long start,
3277 unsigned long end, struct page *ref_page)
3278{
3279 __unmap_hugepage_range(tlb, vma, start, end, ref_page);
3280
3281 /*
3282 * Clear this flag so that x86's huge_pmd_share page_table_shareable
3283 * test will fail on a vma being torn down, and not grab a page table
3284 * on its way out. We're lucky that the flag has such an appropriate
3285 * name, and can in fact be safely cleared here. We could clear it
3286 * before the __unmap_hugepage_range above, but all that's necessary
Davidlohr Buesoc8c06ef2014-12-12 16:54:24 -08003287 * is to clear it before releasing the i_mmap_rwsem. This works
Mel Gormand8333522012-07-31 16:46:20 -07003288 * because in the context this is called, the VMA is about to be
Davidlohr Buesoc8c06ef2014-12-12 16:54:24 -08003289 * destroyed and the i_mmap_rwsem is held.
Mel Gormand8333522012-07-31 16:46:20 -07003290 */
3291 vma->vm_flags &= ~VM_MAYSHARE;
3292}
3293
Chen, Kenneth W502717f2006-10-11 01:20:46 -07003294void unmap_hugepage_range(struct vm_area_struct *vma, unsigned long start,
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003295 unsigned long end, struct page *ref_page)
Chen, Kenneth W502717f2006-10-11 01:20:46 -07003296{
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -07003297 struct mm_struct *mm;
3298 struct mmu_gather tlb;
3299
3300 mm = vma->vm_mm;
3301
Linus Torvalds2b047252013-08-15 11:42:25 -07003302 tlb_gather_mmu(&tlb, mm, start, end);
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -07003303 __unmap_hugepage_range(&tlb, vma, start, end, ref_page);
3304 tlb_finish_mmu(&tlb, start, end);
Chen, Kenneth W502717f2006-10-11 01:20:46 -07003305}
3306
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003307/*
3308 * This is called when the original mapper is failing to COW a MAP_PRIVATE
3309 * mappping it owns the reserve page for. The intention is to unmap the page
3310 * from other VMAs and let the children be SIGKILLed if they are faulting the
3311 * same region.
3312 */
Davidlohr Bueso2f4612a2014-08-06 16:06:45 -07003313static void unmap_ref_private(struct mm_struct *mm, struct vm_area_struct *vma,
3314 struct page *page, unsigned long address)
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003315{
Adam Litke75266742008-11-12 13:24:56 -08003316 struct hstate *h = hstate_vma(vma);
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003317 struct vm_area_struct *iter_vma;
3318 struct address_space *mapping;
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003319 pgoff_t pgoff;
3320
3321 /*
3322 * vm_pgoff is in PAGE_SIZE units, hence the different calculation
3323 * from page cache lookup which is in HPAGE_SIZE units.
3324 */
Adam Litke75266742008-11-12 13:24:56 -08003325 address = address & huge_page_mask(h);
Michal Hocko36e4f202012-10-08 16:33:31 -07003326 pgoff = ((address - vma->vm_start) >> PAGE_SHIFT) +
3327 vma->vm_pgoff;
Al Viro496ad9a2013-01-23 17:07:38 -05003328 mapping = file_inode(vma->vm_file)->i_mapping;
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003329
Mel Gorman4eb2b1d2009-12-14 17:59:53 -08003330 /*
3331 * Take the mapping lock for the duration of the table walk. As
3332 * this mapping should be shared between all the VMAs,
3333 * __unmap_hugepage_range() is called as the lock is already held
3334 */
Davidlohr Bueso83cde9e2014-12-12 16:54:21 -08003335 i_mmap_lock_write(mapping);
Michel Lespinasse6b2dbba2012-10-08 16:31:25 -07003336 vma_interval_tree_foreach(iter_vma, &mapping->i_mmap, pgoff, pgoff) {
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003337 /* Do not unmap the current VMA */
3338 if (iter_vma == vma)
3339 continue;
3340
3341 /*
Mel Gorman2f84a892015-10-01 15:36:57 -07003342 * Shared VMAs have their own reserves and do not affect
3343 * MAP_PRIVATE accounting but it is possible that a shared
3344 * VMA is using the same page so check and skip such VMAs.
3345 */
3346 if (iter_vma->vm_flags & VM_MAYSHARE)
3347 continue;
3348
3349 /*
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003350 * Unmap the page from other VMAs without their own reserves.
3351 * They get marked to be SIGKILLed if they fault in these
3352 * areas. This is because a future no-page fault on this VMA
3353 * could insert a zeroed page instead of the data existing
3354 * from the time of fork. This would look like data corruption
3355 */
3356 if (!is_vma_resv_set(iter_vma, HPAGE_RESV_OWNER))
Aneesh Kumar K.V24669e52012-07-31 16:42:03 -07003357 unmap_hugepage_range(iter_vma, address,
3358 address + huge_page_size(h), page);
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003359 }
Davidlohr Bueso83cde9e2014-12-12 16:54:21 -08003360 i_mmap_unlock_write(mapping);
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003361}
3362
Naoya Horiguchi0fe6e202010-05-28 09:29:16 +09003363/*
3364 * Hugetlb_cow() should be called with page lock of the original hugepage held.
Michal Hockoef009b22012-01-10 15:07:21 -08003365 * Called with hugetlb_instantiation_mutex held and pte_page locked so we
3366 * cannot race with other handlers or page migration.
3367 * Keep the pte_same checks anyway to make transition from the mutex easier.
Naoya Horiguchi0fe6e202010-05-28 09:29:16 +09003368 */
David Gibson1e8f8892006-01-06 00:10:44 -08003369static int hugetlb_cow(struct mm_struct *mm, struct vm_area_struct *vma,
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003370 unsigned long address, pte_t *ptep, pte_t pte,
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003371 struct page *pagecache_page, spinlock_t *ptl)
David Gibson1e8f8892006-01-06 00:10:44 -08003372{
Andi Kleena5516432008-07-23 21:27:41 -07003373 struct hstate *h = hstate_vma(vma);
David Gibson1e8f8892006-01-06 00:10:44 -08003374 struct page *old_page, *new_page;
Davidlohr Buesoad4404a2014-08-06 16:06:47 -07003375 int ret = 0, outside_reserve = 0;
Sagi Grimberg2ec74c32012-10-08 16:33:33 -07003376 unsigned long mmun_start; /* For mmu_notifiers */
3377 unsigned long mmun_end; /* For mmu_notifiers */
David Gibson1e8f8892006-01-06 00:10:44 -08003378
3379 old_page = pte_page(pte);
3380
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003381retry_avoidcopy:
David Gibson1e8f8892006-01-06 00:10:44 -08003382 /* If no-one else is actually using this page, avoid the copy
3383 * and just make the page writable */
Joonsoo Kim37a21402013-09-11 14:21:04 -07003384 if (page_mapcount(old_page) == 1 && PageAnon(old_page)) {
3385 page_move_anon_rmap(old_page, vma, address);
David Gibson1e8f8892006-01-06 00:10:44 -08003386 set_huge_ptep_writable(vma, address, ptep);
Nick Piggin83c54072007-07-19 01:47:05 -07003387 return 0;
David Gibson1e8f8892006-01-06 00:10:44 -08003388 }
3389
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003390 /*
3391 * If the process that created a MAP_PRIVATE mapping is about to
3392 * perform a COW due to a shared page count, attempt to satisfy
3393 * the allocation without using the existing reserves. The pagecache
3394 * page is used to determine if the reserve at this address was
3395 * consumed or not. If reserves were used, a partial faulted mapping
3396 * at the time of fork() could consume its reserves on COW instead
3397 * of the full address range.
3398 */
Joonsoo Kim5944d012013-09-11 14:21:55 -07003399 if (is_vma_resv_set(vma, HPAGE_RESV_OWNER) &&
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003400 old_page != pagecache_page)
3401 outside_reserve = 1;
3402
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03003403 get_page(old_page);
Larry Woodmanb76c8cf2009-12-14 17:59:37 -08003404
Davidlohr Buesoad4404a2014-08-06 16:06:47 -07003405 /*
3406 * Drop page table lock as buddy allocator may be called. It will
3407 * be acquired again before returning to the caller, as expected.
3408 */
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003409 spin_unlock(ptl);
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003410 new_page = alloc_huge_page(vma, address, outside_reserve);
David Gibson1e8f8892006-01-06 00:10:44 -08003411
Adam Litke2fc39ce2007-11-14 16:59:39 -08003412 if (IS_ERR(new_page)) {
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003413 /*
3414 * If a process owning a MAP_PRIVATE mapping fails to COW,
3415 * it is due to references held by a child and an insufficient
3416 * huge page pool. To guarantee the original mappers
3417 * reliability, unmap the page from child processes. The child
3418 * may get SIGKILLed if it later faults.
3419 */
3420 if (outside_reserve) {
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03003421 put_page(old_page);
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003422 BUG_ON(huge_pte_none(pte));
Davidlohr Bueso2f4612a2014-08-06 16:06:45 -07003423 unmap_ref_private(mm, vma, old_page, address);
3424 BUG_ON(huge_pte_none(pte));
3425 spin_lock(ptl);
3426 ptep = huge_pte_offset(mm, address & huge_page_mask(h));
3427 if (likely(ptep &&
3428 pte_same(huge_ptep_get(ptep), pte)))
3429 goto retry_avoidcopy;
3430 /*
3431 * race occurs while re-acquiring page table
3432 * lock, and our job is done.
3433 */
3434 return 0;
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003435 }
3436
Davidlohr Buesoad4404a2014-08-06 16:06:47 -07003437 ret = (PTR_ERR(new_page) == -ENOMEM) ?
3438 VM_FAULT_OOM : VM_FAULT_SIGBUS;
3439 goto out_release_old;
David Gibson1e8f8892006-01-06 00:10:44 -08003440 }
3441
Naoya Horiguchi0fe6e202010-05-28 09:29:16 +09003442 /*
3443 * When the original hugepage is shared one, it does not have
3444 * anon_vma prepared.
3445 */
Dean Nelson44e2aa92010-10-26 14:22:08 -07003446 if (unlikely(anon_vma_prepare(vma))) {
Davidlohr Buesoad4404a2014-08-06 16:06:47 -07003447 ret = VM_FAULT_OOM;
3448 goto out_release_all;
Dean Nelson44e2aa92010-10-26 14:22:08 -07003449 }
Naoya Horiguchi0fe6e202010-05-28 09:29:16 +09003450
Andrea Arcangeli47ad8472011-01-13 15:46:47 -08003451 copy_user_huge_page(new_page, old_page, address, vma,
3452 pages_per_huge_page(h));
Nick Piggin0ed361d2008-02-04 22:29:34 -08003453 __SetPageUptodate(new_page);
Naoya Horiguchibcc54222015-04-15 16:14:38 -07003454 set_page_huge_active(new_page);
David Gibson1e8f8892006-01-06 00:10:44 -08003455
Sagi Grimberg2ec74c32012-10-08 16:33:33 -07003456 mmun_start = address & huge_page_mask(h);
3457 mmun_end = mmun_start + huge_page_size(h);
3458 mmu_notifier_invalidate_range_start(mm, mmun_start, mmun_end);
Davidlohr Buesoad4404a2014-08-06 16:06:47 -07003459
Larry Woodmanb76c8cf2009-12-14 17:59:37 -08003460 /*
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003461 * Retake the page table lock to check for racing updates
Larry Woodmanb76c8cf2009-12-14 17:59:37 -08003462 * before the page tables are altered
3463 */
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003464 spin_lock(ptl);
Andi Kleena5516432008-07-23 21:27:41 -07003465 ptep = huge_pte_offset(mm, address & huge_page_mask(h));
Naoya Horiguchia9af0c52014-04-07 15:36:54 -07003466 if (likely(ptep && pte_same(huge_ptep_get(ptep), pte))) {
Joonsoo Kim07443a82013-09-11 14:21:58 -07003467 ClearPagePrivate(new_page);
3468
David Gibson1e8f8892006-01-06 00:10:44 -08003469 /* Break COW */
Gerald Schaefer8fe627e2008-04-28 02:13:28 -07003470 huge_ptep_clear_flush(vma, address, ptep);
Joerg Roedel34ee6452014-11-13 13:46:09 +11003471 mmu_notifier_invalidate_range(mm, mmun_start, mmun_end);
David Gibson1e8f8892006-01-06 00:10:44 -08003472 set_huge_pte_at(mm, address, ptep,
3473 make_huge_pte(vma, new_page, 1));
Kirill A. Shutemovd281ee62016-01-15 16:52:16 -08003474 page_remove_rmap(old_page, true);
Naoya Horiguchicd67f0d2010-09-10 13:23:04 +09003475 hugepage_add_new_anon_rmap(new_page, vma, address);
David Gibson1e8f8892006-01-06 00:10:44 -08003476 /* Make the old page be freed below */
3477 new_page = old_page;
3478 }
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003479 spin_unlock(ptl);
Sagi Grimberg2ec74c32012-10-08 16:33:33 -07003480 mmu_notifier_invalidate_range_end(mm, mmun_start, mmun_end);
Davidlohr Buesoad4404a2014-08-06 16:06:47 -07003481out_release_all:
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03003482 put_page(new_page);
Davidlohr Buesoad4404a2014-08-06 16:06:47 -07003483out_release_old:
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03003484 put_page(old_page);
Joonsoo Kim83120342013-09-11 14:21:57 -07003485
Davidlohr Buesoad4404a2014-08-06 16:06:47 -07003486 spin_lock(ptl); /* Caller expects lock to be held */
3487 return ret;
David Gibson1e8f8892006-01-06 00:10:44 -08003488}
3489
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003490/* Return the pagecache page at a given address within a VMA */
Andi Kleena5516432008-07-23 21:27:41 -07003491static struct page *hugetlbfs_pagecache_page(struct hstate *h,
3492 struct vm_area_struct *vma, unsigned long address)
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003493{
3494 struct address_space *mapping;
Andy Whitcrofte7c4b0b2008-07-23 21:27:26 -07003495 pgoff_t idx;
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003496
3497 mapping = vma->vm_file->f_mapping;
Andi Kleena5516432008-07-23 21:27:41 -07003498 idx = vma_hugecache_offset(h, vma, address);
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003499
3500 return find_lock_page(mapping, idx);
3501}
3502
Hugh Dickins3ae77f42009-09-21 17:03:33 -07003503/*
3504 * Return whether there is a pagecache page to back given address within VMA.
3505 * Caller follow_hugetlb_page() holds page_table_lock so we cannot lock_page.
3506 */
3507static bool hugetlbfs_pagecache_present(struct hstate *h,
Hugh Dickins2a15efc2009-09-21 17:03:27 -07003508 struct vm_area_struct *vma, unsigned long address)
3509{
3510 struct address_space *mapping;
3511 pgoff_t idx;
3512 struct page *page;
3513
3514 mapping = vma->vm_file->f_mapping;
3515 idx = vma_hugecache_offset(h, vma, address);
3516
3517 page = find_get_page(mapping, idx);
3518 if (page)
3519 put_page(page);
3520 return page != NULL;
3521}
3522
Mike Kravetzab76ad52015-09-08 15:01:50 -07003523int huge_add_to_page_cache(struct page *page, struct address_space *mapping,
3524 pgoff_t idx)
3525{
3526 struct inode *inode = mapping->host;
3527 struct hstate *h = hstate_inode(inode);
3528 int err = add_to_page_cache(page, mapping, idx, GFP_KERNEL);
3529
3530 if (err)
3531 return err;
3532 ClearPagePrivate(page);
3533
3534 spin_lock(&inode->i_lock);
3535 inode->i_blocks += blocks_per_huge_page(h);
3536 spin_unlock(&inode->i_lock);
3537 return 0;
3538}
3539
Robert P. J. Daya1ed3dd2007-07-17 04:03:33 -07003540static int hugetlb_no_page(struct mm_struct *mm, struct vm_area_struct *vma,
Davidlohr Bueso8382d912014-04-03 14:47:31 -07003541 struct address_space *mapping, pgoff_t idx,
3542 unsigned long address, pte_t *ptep, unsigned int flags)
Hugh Dickinsac9b9c62005-10-20 16:24:28 +01003543{
Andi Kleena5516432008-07-23 21:27:41 -07003544 struct hstate *h = hstate_vma(vma);
Hugh Dickinsac9b9c62005-10-20 16:24:28 +01003545 int ret = VM_FAULT_SIGBUS;
Hillf Danton409eb8c2012-01-20 14:34:13 -08003546 int anon_rmap = 0;
Adam Litke4c887262005-10-29 18:16:46 -07003547 unsigned long size;
Adam Litke4c887262005-10-29 18:16:46 -07003548 struct page *page;
David Gibson1e8f8892006-01-06 00:10:44 -08003549 pte_t new_pte;
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003550 spinlock_t *ptl;
Adam Litke4c887262005-10-29 18:16:46 -07003551
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003552 /*
3553 * Currently, we are forced to kill the process in the event the
3554 * original mapper has unmapped pages from the child due to a failed
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003555 * COW. Warn that such a situation has occurred as it may not be obvious
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003556 */
3557 if (is_vma_resv_set(vma, HPAGE_RESV_UNMAPPED)) {
Geoffrey Thomas910154d2016-03-09 14:08:04 -08003558 pr_warn_ratelimited("PID %d killed due to inadequate hugepage pool\n",
Andrew Mortonffb22af2013-02-22 16:32:08 -08003559 current->pid);
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003560 return ret;
3561 }
3562
Adam Litke4c887262005-10-29 18:16:46 -07003563 /*
3564 * Use page lock to guard against racing truncation
3565 * before we get page_table_lock.
3566 */
Christoph Lameter6bda6662006-01-06 00:10:49 -08003567retry:
3568 page = find_lock_page(mapping, idx);
3569 if (!page) {
Andi Kleena5516432008-07-23 21:27:41 -07003570 size = i_size_read(mapping->host) >> huge_page_shift(h);
Hugh Dickinsebed4bf2006-10-28 10:38:43 -07003571 if (idx >= size)
3572 goto out;
Mel Gorman04f2cbe2008-07-23 21:27:25 -07003573 page = alloc_huge_page(vma, address, 0);
Adam Litke2fc39ce2007-11-14 16:59:39 -08003574 if (IS_ERR(page)) {
Aneesh Kumar K.V76dcee72012-07-31 16:41:57 -07003575 ret = PTR_ERR(page);
3576 if (ret == -ENOMEM)
3577 ret = VM_FAULT_OOM;
3578 else
3579 ret = VM_FAULT_SIGBUS;
Christoph Lameter6bda6662006-01-06 00:10:49 -08003580 goto out;
3581 }
Andrea Arcangeli47ad8472011-01-13 15:46:47 -08003582 clear_huge_page(page, address, pages_per_huge_page(h));
Nick Piggin0ed361d2008-02-04 22:29:34 -08003583 __SetPageUptodate(page);
Naoya Horiguchibcc54222015-04-15 16:14:38 -07003584 set_page_huge_active(page);
Hugh Dickinsac9b9c62005-10-20 16:24:28 +01003585
Mel Gormanf83a2752009-05-28 14:34:40 -07003586 if (vma->vm_flags & VM_MAYSHARE) {
Mike Kravetzab76ad52015-09-08 15:01:50 -07003587 int err = huge_add_to_page_cache(page, mapping, idx);
Christoph Lameter6bda6662006-01-06 00:10:49 -08003588 if (err) {
3589 put_page(page);
Christoph Lameter6bda6662006-01-06 00:10:49 -08003590 if (err == -EEXIST)
3591 goto retry;
3592 goto out;
3593 }
Mel Gorman23be7462010-04-23 13:17:56 -04003594 } else {
Christoph Lameter6bda6662006-01-06 00:10:49 -08003595 lock_page(page);
Naoya Horiguchi0fe6e202010-05-28 09:29:16 +09003596 if (unlikely(anon_vma_prepare(vma))) {
3597 ret = VM_FAULT_OOM;
3598 goto backout_unlocked;
3599 }
Hillf Danton409eb8c2012-01-20 14:34:13 -08003600 anon_rmap = 1;
Mel Gorman23be7462010-04-23 13:17:56 -04003601 }
Naoya Horiguchi0fe6e202010-05-28 09:29:16 +09003602 } else {
Naoya Horiguchi998b4382010-09-08 10:19:32 +09003603 /*
3604 * If memory error occurs between mmap() and fault, some process
3605 * don't have hwpoisoned swap entry for errored virtual address.
3606 * So we need to block hugepage fault by PG_hwpoison bit check.
3607 */
3608 if (unlikely(PageHWPoison(page))) {
Chris Forbes32f84522011-07-25 17:12:14 -07003609 ret = VM_FAULT_HWPOISON |
Aneesh Kumar K.V972dc4d2012-07-31 16:42:00 -07003610 VM_FAULT_SET_HINDEX(hstate_index(h));
Naoya Horiguchi998b4382010-09-08 10:19:32 +09003611 goto backout_unlocked;
3612 }
Christoph Lameter6bda6662006-01-06 00:10:49 -08003613 }
David Gibson1e8f8892006-01-06 00:10:44 -08003614
Andy Whitcroft57303d82008-08-12 15:08:47 -07003615 /*
3616 * If we are going to COW a private mapping later, we examine the
3617 * pending reservations for this page now. This will ensure that
3618 * any allocations necessary to record that reservation occur outside
3619 * the spinlock.
3620 */
Mike Kravetz5e911372015-09-08 15:01:28 -07003621 if ((flags & FAULT_FLAG_WRITE) && !(vma->vm_flags & VM_SHARED)) {
Andy Whitcroft2b267362008-08-12 15:08:49 -07003622 if (vma_needs_reservation(h, vma, address) < 0) {
3623 ret = VM_FAULT_OOM;
3624 goto backout_unlocked;
3625 }
Mike Kravetz5e911372015-09-08 15:01:28 -07003626 /* Just decrements count, does not deallocate */
Mike Kravetzfeba16e2015-09-08 15:01:31 -07003627 vma_end_reservation(h, vma, address);
Mike Kravetz5e911372015-09-08 15:01:28 -07003628 }
Andy Whitcroft57303d82008-08-12 15:08:47 -07003629
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003630 ptl = huge_pte_lockptr(h, mm, ptep);
3631 spin_lock(ptl);
Andi Kleena5516432008-07-23 21:27:41 -07003632 size = i_size_read(mapping->host) >> huge_page_shift(h);
Adam Litke4c887262005-10-29 18:16:46 -07003633 if (idx >= size)
3634 goto backout;
3635
Nick Piggin83c54072007-07-19 01:47:05 -07003636 ret = 0;
Gerald Schaefer7f2e9522008-04-28 02:13:29 -07003637 if (!huge_pte_none(huge_ptep_get(ptep)))
Adam Litke4c887262005-10-29 18:16:46 -07003638 goto backout;
3639
Joonsoo Kim07443a82013-09-11 14:21:58 -07003640 if (anon_rmap) {
3641 ClearPagePrivate(page);
Hillf Danton409eb8c2012-01-20 14:34:13 -08003642 hugepage_add_new_anon_rmap(page, vma, address);
Choi Gi-yongac714902014-04-07 15:37:36 -07003643 } else
Kirill A. Shutemov53f92632016-01-15 16:53:42 -08003644 page_dup_rmap(page, true);
David Gibson1e8f8892006-01-06 00:10:44 -08003645 new_pte = make_huge_pte(vma, page, ((vma->vm_flags & VM_WRITE)
3646 && (vma->vm_flags & VM_SHARED)));
3647 set_huge_pte_at(mm, address, ptep, new_pte);
3648
Naoya Horiguchi5d317b22015-11-05 18:47:14 -08003649 hugetlb_count_add(pages_per_huge_page(h), mm);
Hugh Dickins788c7df2009-06-23 13:49:05 +01003650 if ((flags & FAULT_FLAG_WRITE) && !(vma->vm_flags & VM_SHARED)) {
David Gibson1e8f8892006-01-06 00:10:44 -08003651 /* Optimization, do the COW without a second fault */
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003652 ret = hugetlb_cow(mm, vma, address, ptep, new_pte, page, ptl);
David Gibson1e8f8892006-01-06 00:10:44 -08003653 }
3654
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003655 spin_unlock(ptl);
Adam Litke4c887262005-10-29 18:16:46 -07003656 unlock_page(page);
3657out:
Hugh Dickinsac9b9c62005-10-20 16:24:28 +01003658 return ret;
Adam Litke4c887262005-10-29 18:16:46 -07003659
3660backout:
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003661 spin_unlock(ptl);
Andy Whitcroft2b267362008-08-12 15:08:49 -07003662backout_unlocked:
Adam Litke4c887262005-10-29 18:16:46 -07003663 unlock_page(page);
3664 put_page(page);
3665 goto out;
Hugh Dickinsac9b9c62005-10-20 16:24:28 +01003666}
3667
Davidlohr Bueso8382d912014-04-03 14:47:31 -07003668#ifdef CONFIG_SMP
Mike Kravetzc672c7f2015-09-08 15:01:35 -07003669u32 hugetlb_fault_mutex_hash(struct hstate *h, struct mm_struct *mm,
Davidlohr Bueso8382d912014-04-03 14:47:31 -07003670 struct vm_area_struct *vma,
3671 struct address_space *mapping,
3672 pgoff_t idx, unsigned long address)
3673{
3674 unsigned long key[2];
3675 u32 hash;
3676
3677 if (vma->vm_flags & VM_SHARED) {
3678 key[0] = (unsigned long) mapping;
3679 key[1] = idx;
3680 } else {
3681 key[0] = (unsigned long) mm;
3682 key[1] = address >> huge_page_shift(h);
3683 }
3684
3685 hash = jhash2((u32 *)&key, sizeof(key)/sizeof(u32), 0);
3686
3687 return hash & (num_fault_mutexes - 1);
3688}
3689#else
3690/*
3691 * For uniprocesor systems we always use a single mutex, so just
3692 * return 0 and avoid the hashing overhead.
3693 */
Mike Kravetzc672c7f2015-09-08 15:01:35 -07003694u32 hugetlb_fault_mutex_hash(struct hstate *h, struct mm_struct *mm,
Davidlohr Bueso8382d912014-04-03 14:47:31 -07003695 struct vm_area_struct *vma,
3696 struct address_space *mapping,
3697 pgoff_t idx, unsigned long address)
3698{
3699 return 0;
3700}
3701#endif
3702
Adam Litke86e52162006-01-06 00:10:43 -08003703int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
Hugh Dickins788c7df2009-06-23 13:49:05 +01003704 unsigned long address, unsigned int flags)
Adam Litke86e52162006-01-06 00:10:43 -08003705{
Davidlohr Bueso8382d912014-04-03 14:47:31 -07003706 pte_t *ptep, entry;
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003707 spinlock_t *ptl;
David Gibson1e8f8892006-01-06 00:10:44 -08003708 int ret;
Davidlohr Bueso8382d912014-04-03 14:47:31 -07003709 u32 hash;
3710 pgoff_t idx;
Naoya Horiguchi0fe6e202010-05-28 09:29:16 +09003711 struct page *page = NULL;
Andy Whitcroft57303d82008-08-12 15:08:47 -07003712 struct page *pagecache_page = NULL;
Andi Kleena5516432008-07-23 21:27:41 -07003713 struct hstate *h = hstate_vma(vma);
Davidlohr Bueso8382d912014-04-03 14:47:31 -07003714 struct address_space *mapping;
Naoya Horiguchi0f792cf2015-02-11 15:25:25 -08003715 int need_wait_lock = 0;
Adam Litke86e52162006-01-06 00:10:43 -08003716
KAMEZAWA Hiroyuki1e16a532012-01-10 15:07:22 -08003717 address &= huge_page_mask(h);
3718
Naoya Horiguchifd6a03e2010-05-28 09:29:21 +09003719 ptep = huge_pte_offset(mm, address);
3720 if (ptep) {
3721 entry = huge_ptep_get(ptep);
Naoya Horiguchi290408d2010-09-08 10:19:35 +09003722 if (unlikely(is_hugetlb_entry_migration(entry))) {
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003723 migration_entry_wait_huge(vma, mm, ptep);
Naoya Horiguchi290408d2010-09-08 10:19:35 +09003724 return 0;
3725 } else if (unlikely(is_hugetlb_entry_hwpoisoned(entry)))
Chris Forbes32f84522011-07-25 17:12:14 -07003726 return VM_FAULT_HWPOISON_LARGE |
Aneesh Kumar K.V972dc4d2012-07-31 16:42:00 -07003727 VM_FAULT_SET_HINDEX(hstate_index(h));
Naoya Horiguchi0d777df2015-12-11 13:40:49 -08003728 } else {
3729 ptep = huge_pte_alloc(mm, address, huge_page_size(h));
3730 if (!ptep)
3731 return VM_FAULT_OOM;
Naoya Horiguchifd6a03e2010-05-28 09:29:21 +09003732 }
3733
Davidlohr Bueso8382d912014-04-03 14:47:31 -07003734 mapping = vma->vm_file->f_mapping;
3735 idx = vma_hugecache_offset(h, vma, address);
3736
David Gibson3935baa2006-03-22 00:08:53 -08003737 /*
3738 * Serialize hugepage allocation and instantiation, so that we don't
3739 * get spurious allocation failures if two CPUs race to instantiate
3740 * the same page in the page cache.
3741 */
Mike Kravetzc672c7f2015-09-08 15:01:35 -07003742 hash = hugetlb_fault_mutex_hash(h, mm, vma, mapping, idx, address);
3743 mutex_lock(&hugetlb_fault_mutex_table[hash]);
Davidlohr Bueso8382d912014-04-03 14:47:31 -07003744
Gerald Schaefer7f2e9522008-04-28 02:13:29 -07003745 entry = huge_ptep_get(ptep);
3746 if (huge_pte_none(entry)) {
Davidlohr Bueso8382d912014-04-03 14:47:31 -07003747 ret = hugetlb_no_page(mm, vma, mapping, idx, address, ptep, flags);
David Gibsonb4d1d992008-10-15 22:01:11 -07003748 goto out_mutex;
David Gibson3935baa2006-03-22 00:08:53 -08003749 }
Adam Litke86e52162006-01-06 00:10:43 -08003750
Nick Piggin83c54072007-07-19 01:47:05 -07003751 ret = 0;
David Gibson1e8f8892006-01-06 00:10:44 -08003752
Andy Whitcroft57303d82008-08-12 15:08:47 -07003753 /*
Naoya Horiguchi0f792cf2015-02-11 15:25:25 -08003754 * entry could be a migration/hwpoison entry at this point, so this
3755 * check prevents the kernel from going below assuming that we have
3756 * a active hugepage in pagecache. This goto expects the 2nd page fault,
3757 * and is_hugetlb_entry_(migration|hwpoisoned) check will properly
3758 * handle it.
3759 */
3760 if (!pte_present(entry))
3761 goto out_mutex;
3762
3763 /*
Andy Whitcroft57303d82008-08-12 15:08:47 -07003764 * If we are going to COW the mapping later, we examine the pending
3765 * reservations for this page now. This will ensure that any
3766 * allocations necessary to record that reservation occur outside the
3767 * spinlock. For private mappings, we also lookup the pagecache
3768 * page now as it is used to determine if a reservation has been
3769 * consumed.
3770 */
Gerald Schaefer106c9922013-04-29 15:07:23 -07003771 if ((flags & FAULT_FLAG_WRITE) && !huge_pte_write(entry)) {
Andy Whitcroft2b267362008-08-12 15:08:49 -07003772 if (vma_needs_reservation(h, vma, address) < 0) {
3773 ret = VM_FAULT_OOM;
David Gibsonb4d1d992008-10-15 22:01:11 -07003774 goto out_mutex;
Andy Whitcroft2b267362008-08-12 15:08:49 -07003775 }
Mike Kravetz5e911372015-09-08 15:01:28 -07003776 /* Just decrements count, does not deallocate */
Mike Kravetzfeba16e2015-09-08 15:01:31 -07003777 vma_end_reservation(h, vma, address);
Andy Whitcroft57303d82008-08-12 15:08:47 -07003778
Mel Gormanf83a2752009-05-28 14:34:40 -07003779 if (!(vma->vm_flags & VM_MAYSHARE))
Andy Whitcroft57303d82008-08-12 15:08:47 -07003780 pagecache_page = hugetlbfs_pagecache_page(h,
3781 vma, address);
3782 }
3783
Naoya Horiguchi0f792cf2015-02-11 15:25:25 -08003784 ptl = huge_pte_lock(h, mm, ptep);
Naoya Horiguchi0fe6e202010-05-28 09:29:16 +09003785
David Gibson1e8f8892006-01-06 00:10:44 -08003786 /* Check for a racing update before calling hugetlb_cow */
David Gibsonb4d1d992008-10-15 22:01:11 -07003787 if (unlikely(!pte_same(entry, huge_ptep_get(ptep))))
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003788 goto out_ptl;
David Gibsonb4d1d992008-10-15 22:01:11 -07003789
Naoya Horiguchi0f792cf2015-02-11 15:25:25 -08003790 /*
3791 * hugetlb_cow() requires page locks of pte_page(entry) and
3792 * pagecache_page, so here we need take the former one
3793 * when page != pagecache_page or !pagecache_page.
3794 */
3795 page = pte_page(entry);
3796 if (page != pagecache_page)
3797 if (!trylock_page(page)) {
3798 need_wait_lock = 1;
3799 goto out_ptl;
3800 }
3801
3802 get_page(page);
David Gibsonb4d1d992008-10-15 22:01:11 -07003803
Hugh Dickins788c7df2009-06-23 13:49:05 +01003804 if (flags & FAULT_FLAG_WRITE) {
Gerald Schaefer106c9922013-04-29 15:07:23 -07003805 if (!huge_pte_write(entry)) {
Andy Whitcroft57303d82008-08-12 15:08:47 -07003806 ret = hugetlb_cow(mm, vma, address, ptep, entry,
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003807 pagecache_page, ptl);
Naoya Horiguchi0f792cf2015-02-11 15:25:25 -08003808 goto out_put_page;
David Gibsonb4d1d992008-10-15 22:01:11 -07003809 }
Gerald Schaefer106c9922013-04-29 15:07:23 -07003810 entry = huge_pte_mkdirty(entry);
David Gibsonb4d1d992008-10-15 22:01:11 -07003811 }
3812 entry = pte_mkyoung(entry);
Hugh Dickins788c7df2009-06-23 13:49:05 +01003813 if (huge_ptep_set_access_flags(vma, address, ptep, entry,
3814 flags & FAULT_FLAG_WRITE))
Russell King4b3073e2009-12-18 16:40:18 +00003815 update_mmu_cache(vma, address, ptep);
Naoya Horiguchi0f792cf2015-02-11 15:25:25 -08003816out_put_page:
3817 if (page != pagecache_page)
3818 unlock_page(page);
3819 put_page(page);
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003820out_ptl:
3821 spin_unlock(ptl);
Andy Whitcroft57303d82008-08-12 15:08:47 -07003822
3823 if (pagecache_page) {
3824 unlock_page(pagecache_page);
3825 put_page(pagecache_page);
3826 }
David Gibsonb4d1d992008-10-15 22:01:11 -07003827out_mutex:
Mike Kravetzc672c7f2015-09-08 15:01:35 -07003828 mutex_unlock(&hugetlb_fault_mutex_table[hash]);
Naoya Horiguchi0f792cf2015-02-11 15:25:25 -08003829 /*
3830 * Generally it's safe to hold refcount during waiting page lock. But
3831 * here we just wait to defer the next page fault to avoid busy loop and
3832 * the page is not used after unlocked before returning from the current
3833 * page fault. So we are safe from accessing freed page, even if we wait
3834 * here without taking refcount.
3835 */
3836 if (need_wait_lock)
3837 wait_on_page_locked(page);
David Gibson1e8f8892006-01-06 00:10:44 -08003838 return ret;
Adam Litke86e52162006-01-06 00:10:43 -08003839}
3840
Michel Lespinasse28a35712013-02-22 16:35:55 -08003841long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma,
3842 struct page **pages, struct vm_area_struct **vmas,
3843 unsigned long *position, unsigned long *nr_pages,
3844 long i, unsigned int flags)
David Gibson63551ae2005-06-21 17:14:44 -07003845{
Chen, Kenneth Wd5d4b0a2006-03-22 00:09:03 -08003846 unsigned long pfn_offset;
3847 unsigned long vaddr = *position;
Michel Lespinasse28a35712013-02-22 16:35:55 -08003848 unsigned long remainder = *nr_pages;
Andi Kleena5516432008-07-23 21:27:41 -07003849 struct hstate *h = hstate_vma(vma);
David Gibson63551ae2005-06-21 17:14:44 -07003850
David Gibson63551ae2005-06-21 17:14:44 -07003851 while (vaddr < vma->vm_end && remainder) {
Adam Litke4c887262005-10-29 18:16:46 -07003852 pte_t *pte;
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003853 spinlock_t *ptl = NULL;
Hugh Dickins2a15efc2009-09-21 17:03:27 -07003854 int absent;
Adam Litke4c887262005-10-29 18:16:46 -07003855 struct page *page;
3856
3857 /*
David Rientjes02057962015-04-14 15:48:24 -07003858 * If we have a pending SIGKILL, don't keep faulting pages and
3859 * potentially allocating memory.
3860 */
3861 if (unlikely(fatal_signal_pending(current))) {
3862 remainder = 0;
3863 break;
3864 }
3865
3866 /*
Adam Litke4c887262005-10-29 18:16:46 -07003867 * Some archs (sparc64, sh*) have multiple pte_ts to
Hugh Dickins2a15efc2009-09-21 17:03:27 -07003868 * each hugepage. We have to make sure we get the
Adam Litke4c887262005-10-29 18:16:46 -07003869 * first, for the page indexing below to work.
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003870 *
3871 * Note that page table lock is not held when pte is null.
Adam Litke4c887262005-10-29 18:16:46 -07003872 */
Andi Kleena5516432008-07-23 21:27:41 -07003873 pte = huge_pte_offset(mm, vaddr & huge_page_mask(h));
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003874 if (pte)
3875 ptl = huge_pte_lock(h, mm, pte);
Hugh Dickins2a15efc2009-09-21 17:03:27 -07003876 absent = !pte || huge_pte_none(huge_ptep_get(pte));
Adam Litke4c887262005-10-29 18:16:46 -07003877
Hugh Dickins2a15efc2009-09-21 17:03:27 -07003878 /*
3879 * When coredumping, it suits get_dump_page if we just return
Hugh Dickins3ae77f42009-09-21 17:03:33 -07003880 * an error where there's an empty slot with no huge pagecache
3881 * to back it. This way, we avoid allocating a hugepage, and
3882 * the sparse dumpfile avoids allocating disk blocks, but its
3883 * huge holes still show up with zeroes where they need to be.
Hugh Dickins2a15efc2009-09-21 17:03:27 -07003884 */
Hugh Dickins3ae77f42009-09-21 17:03:33 -07003885 if (absent && (flags & FOLL_DUMP) &&
3886 !hugetlbfs_pagecache_present(h, vma, vaddr)) {
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003887 if (pte)
3888 spin_unlock(ptl);
Hugh Dickins2a15efc2009-09-21 17:03:27 -07003889 remainder = 0;
3890 break;
3891 }
3892
Naoya Horiguchi9cc3a5b2013-04-17 15:58:30 -07003893 /*
3894 * We need call hugetlb_fault for both hugepages under migration
3895 * (in which case hugetlb_fault waits for the migration,) and
3896 * hwpoisoned hugepages (in which case we need to prevent the
3897 * caller from accessing to them.) In order to do this, we use
3898 * here is_swap_pte instead of is_hugetlb_entry_migration and
3899 * is_hugetlb_entry_hwpoisoned. This is because it simply covers
3900 * both cases, and because we can't follow correct pages
3901 * directly from any kind of swap entries.
3902 */
3903 if (absent || is_swap_pte(huge_ptep_get(pte)) ||
Gerald Schaefer106c9922013-04-29 15:07:23 -07003904 ((flags & FOLL_WRITE) &&
3905 !huge_pte_write(huge_ptep_get(pte)))) {
Adam Litke4c887262005-10-29 18:16:46 -07003906 int ret;
3907
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003908 if (pte)
3909 spin_unlock(ptl);
Hugh Dickins2a15efc2009-09-21 17:03:27 -07003910 ret = hugetlb_fault(mm, vma, vaddr,
3911 (flags & FOLL_WRITE) ? FAULT_FLAG_WRITE : 0);
Adam Litkea89182c2007-08-22 14:01:51 -07003912 if (!(ret & VM_FAULT_ERROR))
Adam Litke4c887262005-10-29 18:16:46 -07003913 continue;
3914
3915 remainder = 0;
Adam Litke4c887262005-10-29 18:16:46 -07003916 break;
3917 }
David Gibson63551ae2005-06-21 17:14:44 -07003918
Andi Kleena5516432008-07-23 21:27:41 -07003919 pfn_offset = (vaddr & ~huge_page_mask(h)) >> PAGE_SHIFT;
Gerald Schaefer7f2e9522008-04-28 02:13:29 -07003920 page = pte_page(huge_ptep_get(pte));
Chen, Kenneth Wd5d4b0a2006-03-22 00:09:03 -08003921same_page:
Chen, Kenneth Wd6692182006-03-31 02:29:57 -08003922 if (pages) {
Hugh Dickins2a15efc2009-09-21 17:03:27 -07003923 pages[i] = mem_map_offset(page, pfn_offset);
Kirill A. Shutemovddc58f22016-01-15 16:52:56 -08003924 get_page(pages[i]);
Chen, Kenneth Wd6692182006-03-31 02:29:57 -08003925 }
David Gibson63551ae2005-06-21 17:14:44 -07003926
3927 if (vmas)
3928 vmas[i] = vma;
3929
3930 vaddr += PAGE_SIZE;
Chen, Kenneth Wd5d4b0a2006-03-22 00:09:03 -08003931 ++pfn_offset;
David Gibson63551ae2005-06-21 17:14:44 -07003932 --remainder;
3933 ++i;
Chen, Kenneth Wd5d4b0a2006-03-22 00:09:03 -08003934 if (vaddr < vma->vm_end && remainder &&
Andi Kleena5516432008-07-23 21:27:41 -07003935 pfn_offset < pages_per_huge_page(h)) {
Chen, Kenneth Wd5d4b0a2006-03-22 00:09:03 -08003936 /*
3937 * We use pfn_offset to avoid touching the pageframes
3938 * of this compound page.
3939 */
3940 goto same_page;
3941 }
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003942 spin_unlock(ptl);
David Gibson63551ae2005-06-21 17:14:44 -07003943 }
Michel Lespinasse28a35712013-02-22 16:35:55 -08003944 *nr_pages = remainder;
David Gibson63551ae2005-06-21 17:14:44 -07003945 *position = vaddr;
3946
Hugh Dickins2a15efc2009-09-21 17:03:27 -07003947 return i ? i : -EFAULT;
David Gibson63551ae2005-06-21 17:14:44 -07003948}
Zhang, Yanmin8f860592006-03-22 00:08:50 -08003949
Peter Zijlstra7da4d642012-11-19 03:14:23 +01003950unsigned long hugetlb_change_protection(struct vm_area_struct *vma,
Zhang, Yanmin8f860592006-03-22 00:08:50 -08003951 unsigned long address, unsigned long end, pgprot_t newprot)
3952{
3953 struct mm_struct *mm = vma->vm_mm;
3954 unsigned long start = address;
3955 pte_t *ptep;
3956 pte_t pte;
Andi Kleena5516432008-07-23 21:27:41 -07003957 struct hstate *h = hstate_vma(vma);
Peter Zijlstra7da4d642012-11-19 03:14:23 +01003958 unsigned long pages = 0;
Zhang, Yanmin8f860592006-03-22 00:08:50 -08003959
3960 BUG_ON(address >= end);
3961 flush_cache_range(vma, address, end);
3962
Rik van Riela5338092014-04-07 15:36:57 -07003963 mmu_notifier_invalidate_range_start(mm, start, end);
Davidlohr Bueso83cde9e2014-12-12 16:54:21 -08003964 i_mmap_lock_write(vma->vm_file->f_mapping);
Andi Kleena5516432008-07-23 21:27:41 -07003965 for (; address < end; address += huge_page_size(h)) {
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003966 spinlock_t *ptl;
Zhang, Yanmin8f860592006-03-22 00:08:50 -08003967 ptep = huge_pte_offset(mm, address);
3968 if (!ptep)
3969 continue;
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003970 ptl = huge_pte_lock(h, mm, ptep);
Peter Zijlstra7da4d642012-11-19 03:14:23 +01003971 if (huge_pmd_unshare(mm, &address, ptep)) {
3972 pages++;
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08003973 spin_unlock(ptl);
Chen, Kenneth W39dde652006-12-06 20:32:03 -08003974 continue;
Peter Zijlstra7da4d642012-11-19 03:14:23 +01003975 }
Naoya Horiguchia8bda282015-02-11 15:25:28 -08003976 pte = huge_ptep_get(ptep);
3977 if (unlikely(is_hugetlb_entry_hwpoisoned(pte))) {
3978 spin_unlock(ptl);
3979 continue;
3980 }
3981 if (unlikely(is_hugetlb_entry_migration(pte))) {
3982 swp_entry_t entry = pte_to_swp_entry(pte);
3983
3984 if (is_write_migration_entry(entry)) {
3985 pte_t newpte;
3986
3987 make_migration_entry_read(&entry);
3988 newpte = swp_entry_to_pte(entry);
3989 set_huge_pte_at(mm, address, ptep, newpte);
3990 pages++;
3991 }
3992 spin_unlock(ptl);
3993 continue;
3994 }
3995 if (!huge_pte_none(pte)) {
Zhang, Yanmin8f860592006-03-22 00:08:50 -08003996 pte = huge_ptep_get_and_clear(mm, address, ptep);
Gerald Schaefer106c9922013-04-29 15:07:23 -07003997 pte = pte_mkhuge(huge_pte_modify(pte, newprot));
Tony Lube7517d2013-02-04 14:28:46 -08003998 pte = arch_make_huge_pte(pte, vma, NULL, 0);
Zhang, Yanmin8f860592006-03-22 00:08:50 -08003999 set_huge_pte_at(mm, address, ptep, pte);
Peter Zijlstra7da4d642012-11-19 03:14:23 +01004000 pages++;
Zhang, Yanmin8f860592006-03-22 00:08:50 -08004001 }
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08004002 spin_unlock(ptl);
Zhang, Yanmin8f860592006-03-22 00:08:50 -08004003 }
Mel Gormand8333522012-07-31 16:46:20 -07004004 /*
Davidlohr Buesoc8c06ef2014-12-12 16:54:24 -08004005 * Must flush TLB before releasing i_mmap_rwsem: x86's huge_pmd_unshare
Mel Gormand8333522012-07-31 16:46:20 -07004006 * may have cleared our pud entry and done put_page on the page table:
Davidlohr Buesoc8c06ef2014-12-12 16:54:24 -08004007 * once we release i_mmap_rwsem, another task can do the final put_page
Mel Gormand8333522012-07-31 16:46:20 -07004008 * and that page table be reused and filled with junk.
4009 */
Zhang, Yanmin8f860592006-03-22 00:08:50 -08004010 flush_tlb_range(vma, start, end);
Joerg Roedel34ee6452014-11-13 13:46:09 +11004011 mmu_notifier_invalidate_range(mm, start, end);
Davidlohr Bueso83cde9e2014-12-12 16:54:21 -08004012 i_mmap_unlock_write(vma->vm_file->f_mapping);
Rik van Riela5338092014-04-07 15:36:57 -07004013 mmu_notifier_invalidate_range_end(mm, start, end);
Peter Zijlstra7da4d642012-11-19 03:14:23 +01004014
4015 return pages << h->order;
Zhang, Yanmin8f860592006-03-22 00:08:50 -08004016}
4017
Mel Gormana1e78772008-07-23 21:27:23 -07004018int hugetlb_reserve_pages(struct inode *inode,
4019 long from, long to,
Mel Gorman5a6fe122009-02-10 14:02:27 +00004020 struct vm_area_struct *vma,
KOSAKI Motohiroca16d142011-05-26 19:16:19 +09004021 vm_flags_t vm_flags)
Adam Litkee4e574b2007-10-16 01:26:19 -07004022{
Mel Gorman17c9d122009-02-11 16:34:16 +00004023 long ret, chg;
Andi Kleena5516432008-07-23 21:27:41 -07004024 struct hstate *h = hstate_inode(inode);
David Gibson90481622012-03-21 16:34:12 -07004025 struct hugepage_subpool *spool = subpool_inode(inode);
Joonsoo Kim9119a412014-04-03 14:47:25 -07004026 struct resv_map *resv_map;
Mike Kravetz1c5ecae2015-04-15 16:13:39 -07004027 long gbl_reserve;
Adam Litkee4e574b2007-10-16 01:26:19 -07004028
Mel Gormana1e78772008-07-23 21:27:23 -07004029 /*
Mel Gorman17c9d122009-02-11 16:34:16 +00004030 * Only apply hugepage reservation if asked. At fault time, an
4031 * attempt will be made for VM_NORESERVE to allocate a page
David Gibson90481622012-03-21 16:34:12 -07004032 * without using reserves
Mel Gorman17c9d122009-02-11 16:34:16 +00004033 */
KOSAKI Motohiroca16d142011-05-26 19:16:19 +09004034 if (vm_flags & VM_NORESERVE)
Mel Gorman17c9d122009-02-11 16:34:16 +00004035 return 0;
4036
4037 /*
Mel Gormana1e78772008-07-23 21:27:23 -07004038 * Shared mappings base their reservation on the number of pages that
4039 * are already allocated on behalf of the file. Private mappings need
4040 * to reserve the full area even if read-only as mprotect() may be
4041 * called to make the mapping read-write. Assume !vma is a shm mapping
4042 */
Joonsoo Kim9119a412014-04-03 14:47:25 -07004043 if (!vma || vma->vm_flags & VM_MAYSHARE) {
Joonsoo Kim4e35f482014-04-03 14:47:30 -07004044 resv_map = inode_resv_map(inode);
Joonsoo Kim9119a412014-04-03 14:47:25 -07004045
Joonsoo Kim1406ec92014-04-03 14:47:26 -07004046 chg = region_chg(resv_map, from, to);
Joonsoo Kim9119a412014-04-03 14:47:25 -07004047
4048 } else {
4049 resv_map = resv_map_alloc();
Mel Gorman5a6fe122009-02-10 14:02:27 +00004050 if (!resv_map)
4051 return -ENOMEM;
4052
Mel Gorman17c9d122009-02-11 16:34:16 +00004053 chg = to - from;
4054
Mel Gorman5a6fe122009-02-10 14:02:27 +00004055 set_vma_resv_map(vma, resv_map);
4056 set_vma_resv_flags(vma, HPAGE_RESV_OWNER);
4057 }
4058
Dave Hansenc50ac052012-05-29 15:06:46 -07004059 if (chg < 0) {
4060 ret = chg;
4061 goto out_err;
4062 }
Mel Gorman17c9d122009-02-11 16:34:16 +00004063
Mike Kravetz1c5ecae2015-04-15 16:13:39 -07004064 /*
4065 * There must be enough pages in the subpool for the mapping. If
4066 * the subpool has a minimum size, there may be some global
4067 * reservations already in place (gbl_reserve).
4068 */
4069 gbl_reserve = hugepage_subpool_get_pages(spool, chg);
4070 if (gbl_reserve < 0) {
Dave Hansenc50ac052012-05-29 15:06:46 -07004071 ret = -ENOSPC;
4072 goto out_err;
4073 }
Mel Gorman17c9d122009-02-11 16:34:16 +00004074
4075 /*
4076 * Check enough hugepages are available for the reservation.
David Gibson90481622012-03-21 16:34:12 -07004077 * Hand the pages back to the subpool if there are not
Mel Gorman17c9d122009-02-11 16:34:16 +00004078 */
Mike Kravetz1c5ecae2015-04-15 16:13:39 -07004079 ret = hugetlb_acct_memory(h, gbl_reserve);
Mel Gorman17c9d122009-02-11 16:34:16 +00004080 if (ret < 0) {
Mike Kravetz1c5ecae2015-04-15 16:13:39 -07004081 /* put back original number of pages, chg */
4082 (void)hugepage_subpool_put_pages(spool, chg);
Dave Hansenc50ac052012-05-29 15:06:46 -07004083 goto out_err;
Mel Gorman17c9d122009-02-11 16:34:16 +00004084 }
4085
4086 /*
4087 * Account for the reservations made. Shared mappings record regions
4088 * that have reservations as they are shared by multiple VMAs.
4089 * When the last VMA disappears, the region map says how much
4090 * the reservation was and the page cache tells how much of
4091 * the reservation was consumed. Private mappings are per-VMA and
4092 * only the consumed reservations are tracked. When the VMA
4093 * disappears, the original reservation is the VMA size and the
4094 * consumed reservations are stored in the map. Hence, nothing
4095 * else has to be done for private mappings here
4096 */
Mike Kravetz33039672015-06-24 16:57:58 -07004097 if (!vma || vma->vm_flags & VM_MAYSHARE) {
4098 long add = region_add(resv_map, from, to);
4099
4100 if (unlikely(chg > add)) {
4101 /*
4102 * pages in this range were added to the reserve
4103 * map between region_chg and region_add. This
4104 * indicates a race with alloc_huge_page. Adjust
4105 * the subpool and reserve counts modified above
4106 * based on the difference.
4107 */
4108 long rsv_adjust;
4109
4110 rsv_adjust = hugepage_subpool_put_pages(spool,
4111 chg - add);
4112 hugetlb_acct_memory(h, -rsv_adjust);
4113 }
4114 }
Chen, Kenneth Wa43a8c32006-06-23 02:03:15 -07004115 return 0;
Dave Hansenc50ac052012-05-29 15:06:46 -07004116out_err:
Mike Kravetz5e911372015-09-08 15:01:28 -07004117 if (!vma || vma->vm_flags & VM_MAYSHARE)
4118 region_abort(resv_map, from, to);
Joonsoo Kimf031dd22014-04-03 14:47:28 -07004119 if (vma && is_vma_resv_set(vma, HPAGE_RESV_OWNER))
4120 kref_put(&resv_map->refs, resv_map_release);
Dave Hansenc50ac052012-05-29 15:06:46 -07004121 return ret;
Chen, Kenneth Wa43a8c32006-06-23 02:03:15 -07004122}
4123
Mike Kravetzb5cec282015-09-08 15:01:41 -07004124long hugetlb_unreserve_pages(struct inode *inode, long start, long end,
4125 long freed)
Chen, Kenneth Wa43a8c32006-06-23 02:03:15 -07004126{
Andi Kleena5516432008-07-23 21:27:41 -07004127 struct hstate *h = hstate_inode(inode);
Joonsoo Kim4e35f482014-04-03 14:47:30 -07004128 struct resv_map *resv_map = inode_resv_map(inode);
Joonsoo Kim9119a412014-04-03 14:47:25 -07004129 long chg = 0;
David Gibson90481622012-03-21 16:34:12 -07004130 struct hugepage_subpool *spool = subpool_inode(inode);
Mike Kravetz1c5ecae2015-04-15 16:13:39 -07004131 long gbl_reserve;
Ken Chen45c682a2007-11-14 16:59:44 -08004132
Mike Kravetzb5cec282015-09-08 15:01:41 -07004133 if (resv_map) {
4134 chg = region_del(resv_map, start, end);
4135 /*
4136 * region_del() can fail in the rare case where a region
4137 * must be split and another region descriptor can not be
4138 * allocated. If end == LONG_MAX, it will not fail.
4139 */
4140 if (chg < 0)
4141 return chg;
4142 }
4143
Ken Chen45c682a2007-11-14 16:59:44 -08004144 spin_lock(&inode->i_lock);
Eric Sandeene4c6f8b2009-07-29 15:02:16 -07004145 inode->i_blocks -= (blocks_per_huge_page(h) * freed);
Ken Chen45c682a2007-11-14 16:59:44 -08004146 spin_unlock(&inode->i_lock);
4147
Mike Kravetz1c5ecae2015-04-15 16:13:39 -07004148 /*
4149 * If the subpool has a minimum size, the number of global
4150 * reservations to be released may be adjusted.
4151 */
4152 gbl_reserve = hugepage_subpool_put_pages(spool, (chg - freed));
4153 hugetlb_acct_memory(h, -gbl_reserve);
Mike Kravetzb5cec282015-09-08 15:01:41 -07004154
4155 return 0;
Chen, Kenneth Wa43a8c32006-06-23 02:03:15 -07004156}
Naoya Horiguchi93f70f92010-05-28 09:29:20 +09004157
Steve Capper3212b532013-04-23 12:35:02 +01004158#ifdef CONFIG_ARCH_WANT_HUGE_PMD_SHARE
4159static unsigned long page_table_shareable(struct vm_area_struct *svma,
4160 struct vm_area_struct *vma,
4161 unsigned long addr, pgoff_t idx)
4162{
4163 unsigned long saddr = ((idx - svma->vm_pgoff) << PAGE_SHIFT) +
4164 svma->vm_start;
4165 unsigned long sbase = saddr & PUD_MASK;
4166 unsigned long s_end = sbase + PUD_SIZE;
4167
4168 /* Allow segments to share if only one is marked locked */
Eric B Munsonde60f5f2015-11-05 18:51:36 -08004169 unsigned long vm_flags = vma->vm_flags & VM_LOCKED_CLEAR_MASK;
4170 unsigned long svm_flags = svma->vm_flags & VM_LOCKED_CLEAR_MASK;
Steve Capper3212b532013-04-23 12:35:02 +01004171
4172 /*
4173 * match the virtual addresses, permission and the alignment of the
4174 * page table page.
4175 */
4176 if (pmd_index(addr) != pmd_index(saddr) ||
4177 vm_flags != svm_flags ||
4178 sbase < svma->vm_start || svma->vm_end < s_end)
4179 return 0;
4180
4181 return saddr;
4182}
4183
Nicholas Krause31aafb42015-09-04 15:47:58 -07004184static bool vma_shareable(struct vm_area_struct *vma, unsigned long addr)
Steve Capper3212b532013-04-23 12:35:02 +01004185{
4186 unsigned long base = addr & PUD_MASK;
4187 unsigned long end = base + PUD_SIZE;
4188
4189 /*
4190 * check on proper vm_flags and page table alignment
4191 */
4192 if (vma->vm_flags & VM_MAYSHARE &&
4193 vma->vm_start <= base && end <= vma->vm_end)
Nicholas Krause31aafb42015-09-04 15:47:58 -07004194 return true;
4195 return false;
Steve Capper3212b532013-04-23 12:35:02 +01004196}
4197
4198/*
4199 * Search for a shareable pmd page for hugetlb. In any case calls pmd_alloc()
4200 * and returns the corresponding pte. While this is not necessary for the
4201 * !shared pmd case because we can allocate the pmd later as well, it makes the
4202 * code much cleaner. pmd allocation is essential for the shared case because
Davidlohr Buesoc8c06ef2014-12-12 16:54:24 -08004203 * pud has to be populated inside the same i_mmap_rwsem section - otherwise
Steve Capper3212b532013-04-23 12:35:02 +01004204 * racing tasks could either miss the sharing (see huge_pte_offset) or select a
4205 * bad pmd for sharing.
4206 */
4207pte_t *huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud)
4208{
4209 struct vm_area_struct *vma = find_vma(mm, addr);
4210 struct address_space *mapping = vma->vm_file->f_mapping;
4211 pgoff_t idx = ((addr - vma->vm_start) >> PAGE_SHIFT) +
4212 vma->vm_pgoff;
4213 struct vm_area_struct *svma;
4214 unsigned long saddr;
4215 pte_t *spte = NULL;
4216 pte_t *pte;
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08004217 spinlock_t *ptl;
Steve Capper3212b532013-04-23 12:35:02 +01004218
4219 if (!vma_shareable(vma, addr))
4220 return (pte_t *)pmd_alloc(mm, pud, addr);
4221
Davidlohr Bueso83cde9e2014-12-12 16:54:21 -08004222 i_mmap_lock_write(mapping);
Steve Capper3212b532013-04-23 12:35:02 +01004223 vma_interval_tree_foreach(svma, &mapping->i_mmap, idx, idx) {
4224 if (svma == vma)
4225 continue;
4226
4227 saddr = page_table_shareable(svma, vma, addr, idx);
4228 if (saddr) {
4229 spte = huge_pte_offset(svma->vm_mm, saddr);
4230 if (spte) {
Kirill A. Shutemovdc6c9a32015-02-11 15:26:50 -08004231 mm_inc_nr_pmds(mm);
Steve Capper3212b532013-04-23 12:35:02 +01004232 get_page(virt_to_page(spte));
4233 break;
4234 }
4235 }
4236 }
4237
4238 if (!spte)
4239 goto out;
4240
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08004241 ptl = huge_pte_lockptr(hstate_vma(vma), mm, spte);
4242 spin_lock(ptl);
Kirill A. Shutemovdc6c9a32015-02-11 15:26:50 -08004243 if (pud_none(*pud)) {
Steve Capper3212b532013-04-23 12:35:02 +01004244 pud_populate(mm, pud,
4245 (pmd_t *)((unsigned long)spte & PAGE_MASK));
Kirill A. Shutemovdc6c9a32015-02-11 15:26:50 -08004246 } else {
Steve Capper3212b532013-04-23 12:35:02 +01004247 put_page(virt_to_page(spte));
Kirill A. Shutemovdc6c9a32015-02-11 15:26:50 -08004248 mm_inc_nr_pmds(mm);
4249 }
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08004250 spin_unlock(ptl);
Steve Capper3212b532013-04-23 12:35:02 +01004251out:
4252 pte = (pte_t *)pmd_alloc(mm, pud, addr);
Davidlohr Bueso83cde9e2014-12-12 16:54:21 -08004253 i_mmap_unlock_write(mapping);
Steve Capper3212b532013-04-23 12:35:02 +01004254 return pte;
4255}
4256
4257/*
4258 * unmap huge page backed by shared pte.
4259 *
4260 * Hugetlb pte page is ref counted at the time of mapping. If pte is shared
4261 * indicated by page_count > 1, unmap is achieved by clearing pud and
4262 * decrementing the ref count. If count == 1, the pte page is not shared.
4263 *
Kirill A. Shutemovcb900f42013-11-14 14:31:02 -08004264 * called with page table lock held.
Steve Capper3212b532013-04-23 12:35:02 +01004265 *
4266 * returns: 1 successfully unmapped a shared pte page
4267 * 0 the underlying pte page is not shared, or it is the last user
4268 */
4269int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep)
4270{
4271 pgd_t *pgd = pgd_offset(mm, *addr);
4272 pud_t *pud = pud_offset(pgd, *addr);
4273
4274 BUG_ON(page_count(virt_to_page(ptep)) == 0);
4275 if (page_count(virt_to_page(ptep)) == 1)
4276 return 0;
4277
4278 pud_clear(pud);
4279 put_page(virt_to_page(ptep));
Kirill A. Shutemovdc6c9a32015-02-11 15:26:50 -08004280 mm_dec_nr_pmds(mm);
Steve Capper3212b532013-04-23 12:35:02 +01004281 *addr = ALIGN(*addr, HPAGE_SIZE * PTRS_PER_PTE) - HPAGE_SIZE;
4282 return 1;
4283}
Steve Capper9e5fc742013-04-30 08:02:03 +01004284#define want_pmd_share() (1)
4285#else /* !CONFIG_ARCH_WANT_HUGE_PMD_SHARE */
4286pte_t *huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud)
4287{
4288 return NULL;
4289}
Zhang Zhene81f2d22015-06-24 16:56:13 -07004290
4291int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep)
4292{
4293 return 0;
4294}
Steve Capper9e5fc742013-04-30 08:02:03 +01004295#define want_pmd_share() (0)
Steve Capper3212b532013-04-23 12:35:02 +01004296#endif /* CONFIG_ARCH_WANT_HUGE_PMD_SHARE */
4297
Steve Capper9e5fc742013-04-30 08:02:03 +01004298#ifdef CONFIG_ARCH_WANT_GENERAL_HUGETLB
4299pte_t *huge_pte_alloc(struct mm_struct *mm,
4300 unsigned long addr, unsigned long sz)
4301{
4302 pgd_t *pgd;
4303 pud_t *pud;
4304 pte_t *pte = NULL;
4305
4306 pgd = pgd_offset(mm, addr);
4307 pud = pud_alloc(mm, pgd, addr);
4308 if (pud) {
4309 if (sz == PUD_SIZE) {
4310 pte = (pte_t *)pud;
4311 } else {
4312 BUG_ON(sz != PMD_SIZE);
4313 if (want_pmd_share() && pud_none(*pud))
4314 pte = huge_pmd_share(mm, addr, pud);
4315 else
4316 pte = (pte_t *)pmd_alloc(mm, pud, addr);
4317 }
4318 }
4319 BUG_ON(pte && !pte_none(*pte) && !pte_huge(*pte));
4320
4321 return pte;
4322}
4323
4324pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr)
4325{
4326 pgd_t *pgd;
4327 pud_t *pud;
4328 pmd_t *pmd = NULL;
4329
4330 pgd = pgd_offset(mm, addr);
4331 if (pgd_present(*pgd)) {
4332 pud = pud_offset(pgd, addr);
4333 if (pud_present(*pud)) {
4334 if (pud_huge(*pud))
4335 return (pte_t *)pud;
4336 pmd = pmd_offset(pud, addr);
4337 }
4338 }
4339 return (pte_t *) pmd;
4340}
4341
Naoya Horiguchi61f77ed2015-02-11 15:25:15 -08004342#endif /* CONFIG_ARCH_WANT_GENERAL_HUGETLB */
4343
4344/*
4345 * These functions are overwritable if your architecture needs its own
4346 * behavior.
4347 */
4348struct page * __weak
4349follow_huge_addr(struct mm_struct *mm, unsigned long address,
4350 int write)
4351{
4352 return ERR_PTR(-EINVAL);
4353}
4354
4355struct page * __weak
Steve Capper9e5fc742013-04-30 08:02:03 +01004356follow_huge_pmd(struct mm_struct *mm, unsigned long address,
Naoya Horiguchie66f17f2015-02-11 15:25:22 -08004357 pmd_t *pmd, int flags)
Steve Capper9e5fc742013-04-30 08:02:03 +01004358{
Naoya Horiguchie66f17f2015-02-11 15:25:22 -08004359 struct page *page = NULL;
4360 spinlock_t *ptl;
4361retry:
4362 ptl = pmd_lockptr(mm, pmd);
4363 spin_lock(ptl);
4364 /*
4365 * make sure that the address range covered by this pmd is not
4366 * unmapped from other threads.
4367 */
4368 if (!pmd_huge(*pmd))
4369 goto out;
4370 if (pmd_present(*pmd)) {
Gerald Schaefer97534122015-04-14 15:42:30 -07004371 page = pmd_page(*pmd) + ((address & ~PMD_MASK) >> PAGE_SHIFT);
Naoya Horiguchie66f17f2015-02-11 15:25:22 -08004372 if (flags & FOLL_GET)
4373 get_page(page);
4374 } else {
4375 if (is_hugetlb_entry_migration(huge_ptep_get((pte_t *)pmd))) {
4376 spin_unlock(ptl);
4377 __migration_entry_wait(mm, (pte_t *)pmd, ptl);
4378 goto retry;
4379 }
4380 /*
4381 * hwpoisoned entry is treated as no_page_table in
4382 * follow_page_mask().
4383 */
4384 }
4385out:
4386 spin_unlock(ptl);
Steve Capper9e5fc742013-04-30 08:02:03 +01004387 return page;
4388}
4389
Naoya Horiguchi61f77ed2015-02-11 15:25:15 -08004390struct page * __weak
Steve Capper9e5fc742013-04-30 08:02:03 +01004391follow_huge_pud(struct mm_struct *mm, unsigned long address,
Naoya Horiguchie66f17f2015-02-11 15:25:22 -08004392 pud_t *pud, int flags)
Steve Capper9e5fc742013-04-30 08:02:03 +01004393{
Naoya Horiguchie66f17f2015-02-11 15:25:22 -08004394 if (flags & FOLL_GET)
4395 return NULL;
Steve Capper9e5fc742013-04-30 08:02:03 +01004396
Naoya Horiguchie66f17f2015-02-11 15:25:22 -08004397 return pte_page(*(pte_t *)pud) + ((address & ~PUD_MASK) >> PAGE_SHIFT);
Steve Capper9e5fc742013-04-30 08:02:03 +01004398}
4399
Andi Kleend5bd9102010-09-27 09:00:12 +02004400#ifdef CONFIG_MEMORY_FAILURE
4401
Naoya Horiguchi93f70f92010-05-28 09:29:20 +09004402/*
4403 * This function is called from memory failure code.
4404 * Assume the caller holds page lock of the head page.
4405 */
Naoya Horiguchi6de2b1a2010-09-08 10:19:36 +09004406int dequeue_hwpoisoned_huge_page(struct page *hpage)
Naoya Horiguchi93f70f92010-05-28 09:29:20 +09004407{
4408 struct hstate *h = page_hstate(hpage);
4409 int nid = page_to_nid(hpage);
Naoya Horiguchi6de2b1a2010-09-08 10:19:36 +09004410 int ret = -EBUSY;
Naoya Horiguchi93f70f92010-05-28 09:29:20 +09004411
4412 spin_lock(&hugetlb_lock);
Naoya Horiguchi7e1f0492015-04-15 16:14:41 -07004413 /*
4414 * Just checking !page_huge_active is not enough, because that could be
4415 * an isolated/hwpoisoned hugepage (which have >0 refcount).
4416 */
4417 if (!page_huge_active(hpage) && !page_count(hpage)) {
Naoya Horiguchi56f2fb12012-12-12 13:52:33 -08004418 /*
4419 * Hwpoisoned hugepage isn't linked to activelist or freelist,
4420 * but dangling hpage->lru can trigger list-debug warnings
4421 * (this happens when we call unpoison_memory() on it),
4422 * so let it point to itself with list_del_init().
4423 */
4424 list_del_init(&hpage->lru);
Naoya Horiguchi8c6c2ec2010-09-08 10:19:38 +09004425 set_page_refcounted(hpage);
Naoya Horiguchi6de2b1a2010-09-08 10:19:36 +09004426 h->free_huge_pages--;
4427 h->free_huge_pages_node[nid]--;
4428 ret = 0;
4429 }
Naoya Horiguchi93f70f92010-05-28 09:29:20 +09004430 spin_unlock(&hugetlb_lock);
Naoya Horiguchi6de2b1a2010-09-08 10:19:36 +09004431 return ret;
Naoya Horiguchi93f70f92010-05-28 09:29:20 +09004432}
Naoya Horiguchi6de2b1a2010-09-08 10:19:36 +09004433#endif
Naoya Horiguchi31caf662013-09-11 14:21:59 -07004434
4435bool isolate_huge_page(struct page *page, struct list_head *list)
4436{
Naoya Horiguchibcc54222015-04-15 16:14:38 -07004437 bool ret = true;
4438
Sasha Levin309381fea2014-01-23 15:52:54 -08004439 VM_BUG_ON_PAGE(!PageHead(page), page);
Naoya Horiguchi31caf662013-09-11 14:21:59 -07004440 spin_lock(&hugetlb_lock);
Naoya Horiguchibcc54222015-04-15 16:14:38 -07004441 if (!page_huge_active(page) || !get_page_unless_zero(page)) {
4442 ret = false;
4443 goto unlock;
4444 }
4445 clear_page_huge_active(page);
Naoya Horiguchi31caf662013-09-11 14:21:59 -07004446 list_move_tail(&page->lru, list);
Naoya Horiguchibcc54222015-04-15 16:14:38 -07004447unlock:
Naoya Horiguchi31caf662013-09-11 14:21:59 -07004448 spin_unlock(&hugetlb_lock);
Naoya Horiguchibcc54222015-04-15 16:14:38 -07004449 return ret;
Naoya Horiguchi31caf662013-09-11 14:21:59 -07004450}
4451
4452void putback_active_hugepage(struct page *page)
4453{
Sasha Levin309381fea2014-01-23 15:52:54 -08004454 VM_BUG_ON_PAGE(!PageHead(page), page);
Naoya Horiguchi31caf662013-09-11 14:21:59 -07004455 spin_lock(&hugetlb_lock);
Naoya Horiguchibcc54222015-04-15 16:14:38 -07004456 set_page_huge_active(page);
Naoya Horiguchi31caf662013-09-11 14:21:59 -07004457 list_move_tail(&page->lru, &(page_hstate(page))->hugepage_activelist);
4458 spin_unlock(&hugetlb_lock);
4459 put_page(page);
4460}