2 files changed, 52 insertions, 13 deletions

diff --git a/mm/compaction.c b/mm/compaction.c
index 4af1577adb5c..d8a20fcf8678 100644
--- a/mm/compaction.c
+++ b/mm/compaction.c
@@ -1318,7 +1318,8 @@ static enum compact_result compact_finished(struct zone *zone,
  */
 static enum compact_result __compaction_suitable(struct zone *zone, int order,
                                         unsigned int alloc_flags,
-                                        int classzone_idx)
+                                        int classzone_idx,
+                                        unsigned long wmark_target)
 {
         int fragindex;
         unsigned long watermark;
@@ -1341,7 +1342,8 @@ static enum compact_result __compaction_suitable(struct zone *zone, int order,
          * allocated and for a short time, the footprint is higher
          */
         watermark += (2UL << order);
-        if (!zone_watermark_ok(zone, 0, watermark, classzone_idx, alloc_flags))
+        if (!__zone_watermark_ok(zone, 0, watermark, classzone_idx,
+                                 alloc_flags, wmark_target))
                 return COMPACT_SKIPPED;
 
         /*
@@ -1368,7 +1370,8 @@ enum compact_result compaction_suitable(struct zone *zone, int order,
 {
         enum compact_result ret;
 
-        ret = __compaction_suitable(zone, order, alloc_flags, classzone_idx);
+        ret = __compaction_suitable(zone, order, alloc_flags, classzone_idx,
+                                    zone_page_state(zone, NR_FREE_PAGES));
         trace_mm_compaction_suitable(zone, order, ret);
         if (ret == COMPACT_NOT_SUITABLE_ZONE)
                 ret = COMPACT_SKIPPED;
@@ -1376,6 +1379,39 @@ enum compact_result compaction_suitable(struct zone *zone, int order,
         return ret;
 }
 
+bool compaction_zonelist_suitable(struct alloc_context *ac, int order,
+                int alloc_flags)
+{
+        struct zone *zone;
+        struct zoneref *z;
+
+        /*
+         * Make sure at least one zone would pass __compaction_suitable if we continue
+         * retrying the reclaim.
+         */
+        for_each_zone_zonelist_nodemask(zone, z, ac->zonelist, ac->high_zoneidx,
+                                        ac->nodemask) {
+                unsigned long available;
+                enum compact_result compact_result;
+
+                /*
+                 * Do not consider all the reclaimable memory because we do not
+                 * want to trash just for a single high order allocation which
+                 * is even not guaranteed to appear even if __compaction_suitable
+                 * is happy about the watermark check.
+                 */
+                available = zone_reclaimable_pages(zone) / order;
+                available += zone_page_state_snapshot(zone, NR_FREE_PAGES);
+                compact_result = __compaction_suitable(zone, order, alloc_flags,
+                                ac_classzone_idx(ac), available);
+                if (compact_result != COMPACT_SKIPPED &&
+                                compact_result != COMPACT_NOT_SUITABLE_ZONE)
+                        return true;
+        }
+
+        return false;
+}
+
 static enum compact_result compact_zone(struct zone *zone, struct compact_control *cc)
 {
         enum compact_result ret;
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index dea406a62e3d..089f760ce64a 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -2750,10 +2750,9 @@ static inline bool should_fail_alloc_page(gfp_t gfp_mask, unsigned int order)
  * one free page of a suitable size. Checking now avoids taking the zone lock
  * to check in the allocation paths if no pages are free.
  */
-static bool __zone_watermark_ok(struct zone *z, unsigned int order,
-                        unsigned long mark, int classzone_idx,
-                        unsigned int alloc_flags,
-                        long free_pages)
+bool __zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
+                         int classzone_idx, unsigned int alloc_flags,
+                         long free_pages)
 {
         long min = mark;
         int o;
@@ -3256,8 +3255,8 @@ __alloc_pages_direct_compact(gfp_t gfp_mask, unsigned int order,
 }
 
 static inline bool
-should_compact_retry(unsigned int order, enum compact_result compact_result,
-                     enum migrate_mode *migrate_mode,
+should_compact_retry(struct alloc_context *ac, int order, int alloc_flags,
+                     enum compact_result compact_result, enum migrate_mode *migrate_mode,
                      int compaction_retries)
 {
         int max_retries = MAX_COMPACT_RETRIES;
@@ -3281,9 +3280,11 @@ should_compact_retry(unsigned int order, enum compact_result compact_result,
         /*
          * make sure the compaction wasn't deferred or didn't bail out early
          * due to locks contention before we declare that we should give up.
+         * But do not retry if the given zonelist is not suitable for
+         * compaction.
          */
         if (compaction_withdrawn(compact_result))
-                return true;
+                return compaction_zonelist_suitable(ac, order, alloc_flags);
 
         /*
          * !costly requests are much more important than __GFP_REPEAT
@@ -3311,7 +3312,8 @@ __alloc_pages_direct_compact(gfp_t gfp_mask, unsigned int order,
 }
 
 static inline bool
-should_compact_retry(unsigned int order, enum compact_result compact_result,
+should_compact_retry(struct alloc_context *ac, unsigned int order, int alloc_flags,
+                     enum compact_result compact_result,
                      enum migrate_mode *migrate_mode,
                      int compaction_retries)
 {
@@ -3706,8 +3708,9 @@ retry:
          * of free memory (see __compaction_suitable)
          */
         if (did_some_progress > 0 &&
-                        should_compact_retry(order, compact_result,
-                                &migration_mode, compaction_retries))
+                        should_compact_retry(ac, order, alloc_flags,
+                                compact_result, &migration_mode,
+                                compaction_retries))
                 goto retry;
 
         /* Reclaim has failed us, start killing things */