// SPDX-License-Identifier: GPL-2.0

  /*
   * linux/mm/compaction.c
   *
   * Memory compaction for the reduction of external fragmentation. Note that
   * this heavily depends upon page migration to do all the real heavy
   * lifting
   *
   * Copyright IBM Corp. 2007-2010 Mel Gorman <mel@csn.ul.ie>
   */

  #include <linux/cpu.h>

  #include <linux/swap.h>
  #include <linux/migrate.h>
  #include <linux/compaction.h>
  #include <linux/mm_inline.h>

  #include <linux/sched/signal.h>

  #include <linux/backing-dev.h>

  #include <linux/sysctl.h>

  #include <linux/sysfs.h>

  #include <linux/page-isolation.h>

  #include <linux/kasan.h>

  #include <linux/kthread.h>
  #include <linux/freezer.h>

  #include <linux/page_owner.h>

  #include <linux/psi.h>

  #include "internal.h"

  #ifdef CONFIG_COMPACTION
  static inline void count_compact_event(enum vm_event_item item)
  {
  	count_vm_event(item);
  }
  
  static inline void count_compact_events(enum vm_event_item item, long delta)
  {
  	count_vm_events(item, delta);
  }
  #else
  #define count_compact_event(item) do { } while (0)
  #define count_compact_events(item, delta) do { } while (0)
  #endif

  #if defined CONFIG_COMPACTION || defined CONFIG_CMA

  #define CREATE_TRACE_POINTS
  #include <trace/events/compaction.h>

  #define block_start_pfn(pfn, order)	round_down(pfn, 1UL << (order))
  #define block_end_pfn(pfn, order)	ALIGN((pfn) + 1, 1UL << (order))
  #define pageblock_start_pfn(pfn)	block_start_pfn(pfn, pageblock_order)
  #define pageblock_end_pfn(pfn)		block_end_pfn(pfn, pageblock_order)

  /*
   * Fragmentation score check interval for proactive compaction purposes.
   */

  static const unsigned int HPAGE_FRAG_CHECK_INTERVAL_MSEC = 500;

  
  /*
   * Page order with-respect-to which proactive compaction
   * calculates external fragmentation, which is used as
   * the "fragmentation score" of a node/zone.
   */
  #if defined CONFIG_TRANSPARENT_HUGEPAGE
  #define COMPACTION_HPAGE_ORDER	HPAGE_PMD_ORDER

  #elif defined CONFIG_HUGETLBFS

  #define COMPACTION_HPAGE_ORDER	HUGETLB_PAGE_ORDER
  #else
  #define COMPACTION_HPAGE_ORDER	(PMD_SHIFT - PAGE_SHIFT)
  #endif

  static unsigned long release_freepages(struct list_head *freelist)
  {
  	struct page *page, *next;

  	unsigned long high_pfn = 0;

  
  	list_for_each_entry_safe(page, next, freelist, lru) {

  		unsigned long pfn = page_to_pfn(page);

  		list_del(&page->lru);
  		__free_page(page);

  		if (pfn > high_pfn)
  			high_pfn = pfn;

  	}

  	return high_pfn;

  }

  static void split_map_pages(struct list_head *list)

  {

  	unsigned int i, order, nr_pages;
  	struct page *page, *next;
  	LIST_HEAD(tmp_list);
  
  	list_for_each_entry_safe(page, next, list, lru) {
  		list_del(&page->lru);
  
  		order = page_private(page);
  		nr_pages = 1 << order;

  		post_alloc_hook(page, order, __GFP_MOVABLE);

  		if (order)
  			split_page(page, order);

  		for (i = 0; i < nr_pages; i++) {
  			list_add(&page->lru, &tmp_list);
  			page++;
  		}

  	}

  
  	list_splice(&tmp_list, list);

  }

  #ifdef CONFIG_COMPACTION

  int PageMovable(struct page *page)
  {
  	struct address_space *mapping;
  
  	VM_BUG_ON_PAGE(!PageLocked(page), page);
  	if (!__PageMovable(page))
  		return 0;
  
  	mapping = page_mapping(page);
  	if (mapping && mapping->a_ops && mapping->a_ops->isolate_page)
  		return 1;
  
  	return 0;
  }
  EXPORT_SYMBOL(PageMovable);
  
  void __SetPageMovable(struct page *page, struct address_space *mapping)
  {
  	VM_BUG_ON_PAGE(!PageLocked(page), page);
  	VM_BUG_ON_PAGE((unsigned long)mapping & PAGE_MAPPING_MOVABLE, page);
  	page->mapping = (void *)((unsigned long)mapping | PAGE_MAPPING_MOVABLE);
  }
  EXPORT_SYMBOL(__SetPageMovable);
  
  void __ClearPageMovable(struct page *page)
  {

  	VM_BUG_ON_PAGE(!PageMovable(page), page);
  	/*
  	 * Clear registered address_space val with keeping PAGE_MAPPING_MOVABLE
  	 * flag so that VM can catch up released page by driver after isolation.
  	 * With it, VM migration doesn't try to put it back.
  	 */
  	page->mapping = (void *)((unsigned long)page->mapping &
  				PAGE_MAPPING_MOVABLE);
  }
  EXPORT_SYMBOL(__ClearPageMovable);

  /* Do not skip compaction more than 64 times */
  #define COMPACT_MAX_DEFER_SHIFT 6
  
  /*
   * Compaction is deferred when compaction fails to result in a page

   * allocation success. 1 << compact_defer_shift, compactions are skipped up

   * to a limit of 1 << COMPACT_MAX_DEFER_SHIFT
   */

  static void defer_compaction(struct zone *zone, int order)

  {
  	zone->compact_considered = 0;
  	zone->compact_defer_shift++;
  
  	if (order < zone->compact_order_failed)
  		zone->compact_order_failed = order;
  
  	if (zone->compact_defer_shift > COMPACT_MAX_DEFER_SHIFT)
  		zone->compact_defer_shift = COMPACT_MAX_DEFER_SHIFT;
  
  	trace_mm_compaction_defer_compaction(zone, order);
  }
  
  /* Returns true if compaction should be skipped this time */

  static bool compaction_deferred(struct zone *zone, int order)

  {
  	unsigned long defer_limit = 1UL << zone->compact_defer_shift;
  
  	if (order < zone->compact_order_failed)
  		return false;
  
  	/* Avoid possible overflow */

  	if (++zone->compact_considered >= defer_limit) {

  		zone->compact_considered = defer_limit;

  		return false;

  	}

  
  	trace_mm_compaction_deferred(zone, order);
  
  	return true;
  }
  
  /*
   * Update defer tracking counters after successful compaction of given order,
   * which means an allocation either succeeded (alloc_success == true) or is
   * expected to succeed.
   */
  void compaction_defer_reset(struct zone *zone, int order,
  		bool alloc_success)
  {
  	if (alloc_success) {
  		zone->compact_considered = 0;
  		zone->compact_defer_shift = 0;
  	}
  	if (order >= zone->compact_order_failed)
  		zone->compact_order_failed = order + 1;
  
  	trace_mm_compaction_defer_reset(zone, order);
  }
  
  /* Returns true if restarting compaction after many failures */

  static bool compaction_restarting(struct zone *zone, int order)

  {
  	if (order < zone->compact_order_failed)
  		return false;
  
  	return zone->compact_defer_shift == COMPACT_MAX_DEFER_SHIFT &&
  		zone->compact_considered >= 1UL << zone->compact_defer_shift;
  }

  /* Returns true if the pageblock should be scanned for pages to isolate. */
  static inline bool isolation_suitable(struct compact_control *cc,
  					struct page *page)
  {
  	if (cc->ignore_skip_hint)
  		return true;
  
  	return !get_pageblock_skip(page);
  }

  static void reset_cached_positions(struct zone *zone)
  {
  	zone->compact_cached_migrate_pfn[0] = zone->zone_start_pfn;
  	zone->compact_cached_migrate_pfn[1] = zone->zone_start_pfn;

  	zone->compact_cached_free_pfn =

  				pageblock_start_pfn(zone_end_pfn(zone) - 1);

  }

  /*

   * Compound pages of >= pageblock_order should consistently be skipped until

   * released. It is always pointless to compact pages of such order (if they are
   * migratable), and the pageblocks they occupy cannot contain any free pages.

   */

  static bool pageblock_skip_persistent(struct page *page)

  {

  	if (!PageCompound(page))

  		return false;

  
  	page = compound_head(page);
  
  	if (compound_order(page) >= pageblock_order)
  		return true;
  
  	return false;

  }

  static bool
  __reset_isolation_pfn(struct zone *zone, unsigned long pfn, bool check_source,
  							bool check_target)
  {
  	struct page *page = pfn_to_online_page(pfn);

  	struct page *block_page;

  	struct page *end_page;
  	unsigned long block_pfn;
  
  	if (!page)
  		return false;
  	if (zone != page_zone(page))
  		return false;
  	if (pageblock_skip_persistent(page))
  		return false;
  
  	/*
  	 * If skip is already cleared do no further checking once the
  	 * restart points have been set.
  	 */
  	if (check_source && check_target && !get_pageblock_skip(page))
  		return true;
  
  	/*
  	 * If clearing skip for the target scanner, do not select a
  	 * non-movable pageblock as the starting point.
  	 */
  	if (!check_source && check_target &&
  	    get_pageblock_migratetype(page) != MIGRATE_MOVABLE)
  		return false;

  	/* Ensure the start of the pageblock or zone is online and valid */
  	block_pfn = pageblock_start_pfn(pfn);

  	block_pfn = max(block_pfn, zone->zone_start_pfn);
  	block_page = pfn_to_online_page(block_pfn);

  	if (block_page) {
  		page = block_page;
  		pfn = block_pfn;
  	}
  
  	/* Ensure the end of the pageblock or zone is online and valid */

  	block_pfn = pageblock_end_pfn(pfn) - 1;

  	block_pfn = min(block_pfn, zone_end_pfn(zone) - 1);
  	end_page = pfn_to_online_page(block_pfn);
  	if (!end_page)
  		return false;

  	/*
  	 * Only clear the hint if a sample indicates there is either a
  	 * free page or an LRU page in the block. One or other condition
  	 * is necessary for the block to be a migration source/target.
  	 */

  	do {

  		if (check_source && PageLRU(page)) {
  			clear_pageblock_skip(page);
  			return true;
  		}

  		if (check_target && PageBuddy(page)) {
  			clear_pageblock_skip(page);
  			return true;

  		}
  
  		page += (1 << PAGE_ALLOC_COSTLY_ORDER);
  		pfn += (1 << PAGE_ALLOC_COSTLY_ORDER);

  	} while (page <= end_page);

  
  	return false;
  }

  /*

   * This function is called to clear all cached information on pageblocks that
   * should be skipped for page isolation when the migrate and free page scanner
   * meet.
   */

  static void __reset_isolation_suitable(struct zone *zone)

  {

  	unsigned long migrate_pfn = zone->zone_start_pfn;

  	unsigned long free_pfn = zone_end_pfn(zone) - 1;

  	unsigned long reset_migrate = free_pfn;
  	unsigned long reset_free = migrate_pfn;
  	bool source_set = false;
  	bool free_set = false;
  
  	if (!zone->compact_blockskip_flush)
  		return;

  	zone->compact_blockskip_flush = false;

  	/*
  	 * Walk the zone and update pageblock skip information. Source looks
  	 * for PageLRU while target looks for PageBuddy. When the scanner
  	 * is found, both PageBuddy and PageLRU are checked as the pageblock
  	 * is suitable as both source and target.
  	 */
  	for (; migrate_pfn < free_pfn; migrate_pfn += pageblock_nr_pages,
  					free_pfn -= pageblock_nr_pages) {

  		cond_resched();

  		/* Update the migrate PFN */
  		if (__reset_isolation_pfn(zone, migrate_pfn, true, source_set) &&
  		    migrate_pfn < reset_migrate) {
  			source_set = true;
  			reset_migrate = migrate_pfn;
  			zone->compact_init_migrate_pfn = reset_migrate;
  			zone->compact_cached_migrate_pfn[0] = reset_migrate;
  			zone->compact_cached_migrate_pfn[1] = reset_migrate;
  		}

  		/* Update the free PFN */
  		if (__reset_isolation_pfn(zone, free_pfn, free_set, true) &&
  		    free_pfn > reset_free) {
  			free_set = true;
  			reset_free = free_pfn;
  			zone->compact_init_free_pfn = reset_free;
  			zone->compact_cached_free_pfn = reset_free;
  		}

  	}

  	/* Leave no distance if no suitable block was reset */
  	if (reset_migrate >= reset_free) {
  		zone->compact_cached_migrate_pfn[0] = migrate_pfn;
  		zone->compact_cached_migrate_pfn[1] = migrate_pfn;
  		zone->compact_cached_free_pfn = free_pfn;
  	}

  }

  void reset_isolation_suitable(pg_data_t *pgdat)
  {
  	int zoneid;
  
  	for (zoneid = 0; zoneid < MAX_NR_ZONES; zoneid++) {
  		struct zone *zone = &pgdat->node_zones[zoneid];
  		if (!populated_zone(zone))
  			continue;
  
  		/* Only flush if a full compaction finished recently */
  		if (zone->compact_blockskip_flush)
  			__reset_isolation_suitable(zone);
  	}
  }

  /*

   * Sets the pageblock skip bit if it was clear. Note that this is a hint as
   * locks are not required for read/writers. Returns true if it was already set.
   */
  static bool test_and_set_skip(struct compact_control *cc, struct page *page,
  							unsigned long pfn)
  {
  	bool skip;
  
  	/* Do no update if skip hint is being ignored */
  	if (cc->ignore_skip_hint)
  		return false;
  
  	if (!IS_ALIGNED(pfn, pageblock_nr_pages))
  		return false;
  
  	skip = get_pageblock_skip(page);
  	if (!skip && !cc->no_set_skip_hint)
  		set_pageblock_skip(page);
  
  	return skip;
  }
  
  static void update_cached_migrate(struct compact_control *cc, unsigned long pfn)
  {
  	struct zone *zone = cc->zone;
  
  	pfn = pageblock_end_pfn(pfn);
  
  	/* Set for isolation rather than compaction */
  	if (cc->no_set_skip_hint)
  		return;
  
  	if (pfn > zone->compact_cached_migrate_pfn[0])
  		zone->compact_cached_migrate_pfn[0] = pfn;
  	if (cc->mode != MIGRATE_ASYNC &&
  	    pfn > zone->compact_cached_migrate_pfn[1])
  		zone->compact_cached_migrate_pfn[1] = pfn;
  }
  
  /*

   * If no pages were isolated then mark this pageblock to be skipped in the

   * future. The information is later cleared by __reset_isolation_suitable().

   */

  static void update_pageblock_skip(struct compact_control *cc,

  			struct page *page, unsigned long pfn)

  {

  	struct zone *zone = cc->zone;

  	if (cc->no_set_skip_hint)

  		return;

  	if (!page)
  		return;

  	set_pageblock_skip(page);

  	/* Update where async and sync compaction should restart */

  	if (pfn < zone->compact_cached_free_pfn)
  		zone->compact_cached_free_pfn = pfn;

  }
  #else
  static inline bool isolation_suitable(struct compact_control *cc,
  					struct page *page)
  {
  	return true;
  }

  static inline bool pageblock_skip_persistent(struct page *page)

  {
  	return false;
  }
  
  static inline void update_pageblock_skip(struct compact_control *cc,

  			struct page *page, unsigned long pfn)

  {
  }

  
  static void update_cached_migrate(struct compact_control *cc, unsigned long pfn)
  {
  }
  
  static bool test_and_set_skip(struct compact_control *cc, struct page *page,
  							unsigned long pfn)
  {
  	return false;
  }

  #endif /* CONFIG_COMPACTION */

  /*
   * Compaction requires the taking of some coarse locks that are potentially

   * very heavily contended. For async compaction, trylock and record if the
   * lock is contended. The lock will still be acquired but compaction will
   * abort when the current block is finished regardless of success rate.
   * Sync compaction acquires the lock.

   *

   * Always returns true which makes it easier to track lock state in callers.

   */

  static bool compact_lock_irqsave(spinlock_t *lock, unsigned long *flags,

  						struct compact_control *cc)

  	__acquires(lock)

  {

  	/* Track if the lock is contended in async mode */
  	if (cc->mode == MIGRATE_ASYNC && !cc->contended) {
  		if (spin_trylock_irqsave(lock, *flags))
  			return true;
  
  		cc->contended = true;

  	}

  	spin_lock_irqsave(lock, *flags);

  	return true;

  }

  /*

   * Compaction requires the taking of some coarse locks that are potentially

   * very heavily contended. The lock should be periodically unlocked to avoid
   * having disabled IRQs for a long time, even when there is nobody waiting on
   * the lock. It might also be that allowing the IRQs will result in
   * need_resched() becoming true. If scheduling is needed, async compaction
   * aborts. Sync compaction schedules.
   * Either compaction type will also abort if a fatal signal is pending.
   * In either case if the lock was locked, it is dropped and not regained.

   *

   * Returns true if compaction should abort due to fatal signal pending, or
   *		async compaction due to need_resched()
   * Returns false when compaction can continue (sync compaction might have
   *		scheduled)

   */

  static bool compact_unlock_should_abort(spinlock_t *lock,
  		unsigned long flags, bool *locked, struct compact_control *cc)

  {

  	if (*locked) {
  		spin_unlock_irqrestore(lock, flags);
  		*locked = false;
  	}

  	if (fatal_signal_pending(current)) {

  		cc->contended = true;

  		return true;
  	}

  	cond_resched();

  
  	return false;
  }

  /*

   * Isolate free pages onto a private freelist. If @strict is true, will abort
   * returning 0 on any invalid PFNs or non-free pages inside of the pageblock
   * (even though it may still end up isolating some pages).

   */

  static unsigned long isolate_freepages_block(struct compact_control *cc,

  				unsigned long *start_pfn,

  				unsigned long end_pfn,
  				struct list_head *freelist,

  				unsigned int stride,

  				bool strict)

  {

  	int nr_scanned = 0, total_isolated = 0;

  	struct page *cursor;

  	unsigned long flags = 0;

  	bool locked = false;

  	unsigned long blockpfn = *start_pfn;

  	unsigned int order;

  	/* Strict mode is for isolation, speed is secondary */
  	if (strict)
  		stride = 1;

  	cursor = pfn_to_page(blockpfn);

  	/* Isolate free pages. */

  	for (; blockpfn < end_pfn; blockpfn += stride, cursor += stride) {

  		int isolated;

  		struct page *page = cursor;

  		/*
  		 * Periodically drop the lock (if held) regardless of its
  		 * contention, to give chance to IRQs. Abort if fatal signal
  		 * pending or async compaction detects need_resched()
  		 */
  		if (!(blockpfn % SWAP_CLUSTER_MAX)
  		    && compact_unlock_should_abort(&cc->zone->lock, flags,
  								&locked, cc))
  			break;

  		nr_scanned++;

  		/*
  		 * For compound pages such as THP and hugetlbfs, we can save
  		 * potentially a lot of iterations if we skip them at once.
  		 * The check is racy, but we can consider only valid values
  		 * and the only danger is skipping too much.
  		 */
  		if (PageCompound(page)) {

  			const unsigned int order = compound_order(page);

  			if (likely(order < MAX_ORDER)) {

  				blockpfn += (1UL << order) - 1;
  				cursor += (1UL << order) - 1;

  			}

  			goto isolate_fail;
  		}

  		if (!PageBuddy(page))

  			goto isolate_fail;

  
  		/*

  		 * If we already hold the lock, we can skip some rechecking.
  		 * Note that if we hold the lock now, checked_pageblock was
  		 * already set in some previous iteration (or strict is true),
  		 * so it is correct to skip the suitable migration target
  		 * recheck as well.

  		 */

  		if (!locked) {

  			locked = compact_lock_irqsave(&cc->zone->lock,

  								&flags, cc);

  			/* Recheck this is a buddy page under lock */
  			if (!PageBuddy(page))
  				goto isolate_fail;
  		}

  		/* Found a free page, will break it into order-0 pages */

  		order = buddy_order(page);

  		isolated = __isolate_free_page(page, order);

  		if (!isolated)
  			break;

  		set_page_private(page, order);

  		total_isolated += isolated;

  		cc->nr_freepages += isolated;

  		list_add_tail(&page->lru, freelist);

  		if (!strict && cc->nr_migratepages <= cc->nr_freepages) {
  			blockpfn += isolated;
  			break;

  		}

  		/* Advance to the end of split page */
  		blockpfn += isolated - 1;
  		cursor += isolated - 1;
  		continue;

  
  isolate_fail:
  		if (strict)
  			break;
  		else
  			continue;

  	}

  	if (locked)
  		spin_unlock_irqrestore(&cc->zone->lock, flags);

  	/*
  	 * There is a tiny chance that we have read bogus compound_order(),
  	 * so be careful to not go outside of the pageblock.
  	 */
  	if (unlikely(blockpfn > end_pfn))
  		blockpfn = end_pfn;

  	trace_mm_compaction_isolate_freepages(*start_pfn, blockpfn,
  					nr_scanned, total_isolated);

  	/* Record how far we have got within the block */
  	*start_pfn = blockpfn;

  	/*
  	 * If strict isolation is requested by CMA then check that all the
  	 * pages requested were isolated. If there were any failures, 0 is
  	 * returned and CMA will fail.
  	 */

  	if (strict && blockpfn < end_pfn)

  		total_isolated = 0;

  	cc->total_free_scanned += nr_scanned;

  	if (total_isolated)

  		count_compact_events(COMPACTISOLATED, total_isolated);

  	return total_isolated;
  }

  /**
   * isolate_freepages_range() - isolate free pages.

   * @cc:        Compaction control structure.

   * @start_pfn: The first PFN to start isolating.
   * @end_pfn:   The one-past-last PFN.
   *
   * Non-free pages, invalid PFNs, or zone boundaries within the
   * [start_pfn, end_pfn) range are considered errors, cause function to
   * undo its actions and return zero.
   *
   * Otherwise, function returns one-past-the-last PFN of isolated page
   * (which may be greater then end_pfn if end fell in a middle of
   * a free page).
   */

  unsigned long

  isolate_freepages_range(struct compact_control *cc,
  			unsigned long start_pfn, unsigned long end_pfn)

  {

  	unsigned long isolated, pfn, block_start_pfn, block_end_pfn;

  	LIST_HEAD(freelist);

  	pfn = start_pfn;

  	block_start_pfn = pageblock_start_pfn(pfn);

  	if (block_start_pfn < cc->zone->zone_start_pfn)
  		block_start_pfn = cc->zone->zone_start_pfn;

  	block_end_pfn = pageblock_end_pfn(pfn);

  
  	for (; pfn < end_pfn; pfn += isolated,

  				block_start_pfn = block_end_pfn,

  				block_end_pfn += pageblock_nr_pages) {

  		/* Protect pfn from changing by isolate_freepages_block */
  		unsigned long isolate_start_pfn = pfn;

  		block_end_pfn = min(block_end_pfn, end_pfn);

  		/*
  		 * pfn could pass the block_end_pfn if isolated freepage
  		 * is more than pageblock order. In this case, we adjust
  		 * scanning range to right one.
  		 */
  		if (pfn >= block_end_pfn) {

  			block_start_pfn = pageblock_start_pfn(pfn);
  			block_end_pfn = pageblock_end_pfn(pfn);

  			block_end_pfn = min(block_end_pfn, end_pfn);
  		}

  		if (!pageblock_pfn_to_page(block_start_pfn,
  					block_end_pfn, cc->zone))

  			break;

  		isolated = isolate_freepages_block(cc, &isolate_start_pfn,

  					block_end_pfn, &freelist, 0, true);

  
  		/*
  		 * In strict mode, isolate_freepages_block() returns 0 if
  		 * there are any holes in the block (ie. invalid PFNs or
  		 * non-free pages).
  		 */
  		if (!isolated)
  			break;
  
  		/*
  		 * If we managed to isolate pages, it is always (1 << n) *
  		 * pageblock_nr_pages for some non-negative n.  (Max order
  		 * page may span two pageblocks).
  		 */
  	}

  	/* __isolate_free_page() does not map the pages */

  	split_map_pages(&freelist);

  
  	if (pfn < end_pfn) {
  		/* Loop terminated early, cleanup. */
  		release_freepages(&freelist);
  		return 0;
  	}
  
  	/* We don't use freelists for anything. */
  	return pfn;
  }

  /* Similar to reclaim, but different enough that they don't share logic */

  static bool too_many_isolated(pg_data_t *pgdat)

  {

  	unsigned long active, inactive, isolated;

  	inactive = node_page_state(pgdat, NR_INACTIVE_FILE) +
  			node_page_state(pgdat, NR_INACTIVE_ANON);
  	active = node_page_state(pgdat, NR_ACTIVE_FILE) +
  			node_page_state(pgdat, NR_ACTIVE_ANON);
  	isolated = node_page_state(pgdat, NR_ISOLATED_FILE) +
  			node_page_state(pgdat, NR_ISOLATED_ANON);

  	return isolated > (inactive + active) / 2;

  }

  /**

   * isolate_migratepages_block() - isolate all migrate-able pages within
   *				  a single pageblock

   * @cc:		Compaction control structure.

   * @low_pfn:	The first PFN to isolate
   * @end_pfn:	The one-past-the-last PFN to isolate, within same pageblock
   * @isolate_mode: Isolation mode to be used.

   *
   * Isolate all pages that can be migrated from the range specified by

   * [low_pfn, end_pfn). The range is expected to be within same pageblock.

   * Returns errno, like -EAGAIN or -EINTR in case e.g signal pending or congestion,

   * -ENOMEM in case we could not allocate a page, or 0.

   * cc->migrate_pfn will contain the next pfn to scan.

   *

   * The pages are isolated on cc->migratepages list (not required to be empty),

   * and cc->nr_migratepages is updated accordingly.

   */

  static int

  isolate_migratepages_block(struct compact_control *cc, unsigned long low_pfn,
  			unsigned long end_pfn, isolate_mode_t isolate_mode)

  {

  	pg_data_t *pgdat = cc->zone->zone_pgdat;

  	unsigned long nr_scanned = 0, nr_isolated = 0;

  	struct lruvec *lruvec;

  	unsigned long flags = 0;

  	struct lruvec *locked = NULL;

  	struct page *page = NULL, *valid_page = NULL;

  	unsigned long start_pfn = low_pfn;

  	bool skip_on_failure = false;
  	unsigned long next_skip_pfn = 0;

  	bool skip_updated = false;

  	int ret = 0;
  
  	cc->migrate_pfn = low_pfn;

  	/*
  	 * Ensure that there are not too many pages isolated from the LRU
  	 * list by either parallel reclaimers or compaction. If there are,
  	 * delay for some time until fewer pages are isolated
  	 */

  	while (unlikely(too_many_isolated(pgdat))) {

  		/* stop isolation if there are still pages not migrated */
  		if (cc->nr_migratepages)

  			return -EAGAIN;

  		/* async migration should just abort */

  		if (cc->mode == MIGRATE_ASYNC)

  			return -EAGAIN;

  		congestion_wait(BLK_RW_ASYNC, HZ/10);
  
  		if (fatal_signal_pending(current))

  			return -EINTR;

  	}

  	cond_resched();

  	if (cc->direct_compaction && (cc->mode == MIGRATE_ASYNC)) {
  		skip_on_failure = true;
  		next_skip_pfn = block_end_pfn(low_pfn, cc->order);
  	}

  	/* Time to isolate some pages for migration */

  	for (; low_pfn < end_pfn; low_pfn++) {

  		if (skip_on_failure && low_pfn >= next_skip_pfn) {
  			/*
  			 * We have isolated all migration candidates in the
  			 * previous order-aligned block, and did not skip it due
  			 * to failure. We should migrate the pages now and
  			 * hopefully succeed compaction.
  			 */
  			if (nr_isolated)
  				break;
  
  			/*
  			 * We failed to isolate in the previous order-aligned
  			 * block. Set the new boundary to the end of the
  			 * current block. Note we can't simply increase
  			 * next_skip_pfn by 1 << order, as low_pfn might have
  			 * been incremented by a higher number due to skipping
  			 * a compound or a high-order buddy page in the
  			 * previous loop iteration.
  			 */
  			next_skip_pfn = block_end_pfn(low_pfn, cc->order);
  		}

  		/*
  		 * Periodically drop the lock (if held) regardless of its

  		 * contention, to give chance to IRQs. Abort completely if
  		 * a fatal signal is pending.

  		 */

  		if (!(low_pfn % SWAP_CLUSTER_MAX)) {
  			if (locked) {
  				unlock_page_lruvec_irqrestore(locked, flags);
  				locked = NULL;
  			}
  
  			if (fatal_signal_pending(current)) {
  				cc->contended = true;

  				ret = -EINTR;

  				goto fatal_pending;
  			}
  
  			cond_resched();

  		}

  		nr_scanned++;

  		page = pfn_to_page(low_pfn);

  		/*
  		 * Check if the pageblock has already been marked skipped.
  		 * Only the aligned PFN is checked as the caller isolates
  		 * COMPACT_CLUSTER_MAX at a time so the second call must
  		 * not falsely conclude that the block should be skipped.
  		 */
  		if (!valid_page && IS_ALIGNED(low_pfn, pageblock_nr_pages)) {
  			if (!cc->ignore_skip_hint && get_pageblock_skip(page)) {
  				low_pfn = end_pfn;

  				page = NULL;

  				goto isolate_abort;
  			}

  			valid_page = page;

  		}

  		if (PageHuge(page) && cc->alloc_contig) {

  			ret = isolate_or_dissolve_huge_page(page, &cc->migratepages);

  
  			/*
  			 * Fail isolation in case isolate_or_dissolve_huge_page()
  			 * reports an error. In case of -ENOMEM, abort right away.
  			 */
  			if (ret < 0) {
  				 /* Do not report -EBUSY down the chain */
  				if (ret == -EBUSY)
  					ret = 0;
  				low_pfn += (1UL << compound_order(page)) - 1;
  				goto isolate_fail;
  			}

  			if (PageHuge(page)) {
  				/*
  				 * Hugepage was successfully isolated and placed
  				 * on the cc->migratepages list.
  				 */
  				low_pfn += compound_nr(page) - 1;
  				goto isolate_success_no_list;
  			}

  			/*
  			 * Ok, the hugepage was dissolved. Now these pages are
  			 * Buddy and cannot be re-allocated because they are
  			 * isolated. Fall-through as the check below handles
  			 * Buddy pages.
  			 */
  		}

  		/*

  		 * Skip if free. We read page order here without zone lock
  		 * which is generally unsafe, but the race window is small and
  		 * the worst thing that can happen is that we skip some
  		 * potential isolation targets.

  		 */

  		if (PageBuddy(page)) {

  			unsigned long freepage_order = buddy_order_unsafe(page);

  
  			/*
  			 * Without lock, we cannot be sure that what we got is
  			 * a valid page order. Consider only values in the
  			 * valid order range to prevent low_pfn overflow.
  			 */
  			if (freepage_order > 0 && freepage_order < MAX_ORDER)
  				low_pfn += (1UL << freepage_order) - 1;

  			continue;

  		}

  		/*

  		 * Regardless of being on LRU, compound pages such as THP and

  		 * hugetlbfs are not to be compacted unless we are attempting
  		 * an allocation much larger than the huge page size (eg CMA).
  		 * We can potentially save a lot of iterations if we skip them
  		 * at once. The check is racy, but we can consider only valid
  		 * values and the only danger is skipping too much.

  		 */

  		if (PageCompound(page) && !cc->alloc_contig) {

  			const unsigned int order = compound_order(page);

  			if (likely(order < MAX_ORDER))

  				low_pfn += (1UL << order) - 1;

  			goto isolate_fail;

  		}

  		/*
  		 * Check may be lockless but that's ok as we recheck later.
  		 * It's possible to migrate LRU and non-lru movable pages.
  		 * Skip any other type of page
  		 */
  		if (!PageLRU(page)) {

  			/*
  			 * __PageMovable can return false positive so we need
  			 * to verify it under page_lock.
  			 */
  			if (unlikely(__PageMovable(page)) &&
  					!PageIsolated(page)) {
  				if (locked) {

  					unlock_page_lruvec_irqrestore(locked, flags);
  					locked = NULL;

  				}

  				if (!isolate_movable_page(page, isolate_mode))

  					goto isolate_success;
  			}

  			goto isolate_fail;

  		}

  		/*
  		 * Migration will fail if an anonymous page is pinned in memory,
  		 * so avoid taking lru_lock and isolating it unnecessarily in an
  		 * admittedly racy check.
  		 */
  		if (!page_mapping(page) &&
  		    page_count(page) > page_mapcount(page))

  			goto isolate_fail;

  		/*
  		 * Only allow to migrate anonymous pages in GFP_NOFS context
  		 * because those do not depend on fs locks.
  		 */
  		if (!(cc->gfp_mask & __GFP_FS) && page_mapping(page))
  			goto isolate_fail;

  		/*
  		 * Be careful not to clear PageLRU until after we're
  		 * sure the page is not being freed elsewhere -- the
  		 * page release code relies on it.
  		 */
  		if (unlikely(!get_page_unless_zero(page)))
  			goto isolate_fail;

  		if (!__isolate_lru_page_prepare(page, isolate_mode))

  			goto isolate_fail_put;
  
  		/* Try isolate the page */
  		if (!TestClearPageLRU(page))
  			goto isolate_fail_put;

  		lruvec = mem_cgroup_page_lruvec(page);

  		/* If we already hold the lock, we can skip some rechecking */

  		if (lruvec != locked) {
  			if (locked)
  				unlock_page_lruvec_irqrestore(locked, flags);
  
  			compact_lock_irqsave(&lruvec->lru_lock, &flags, cc);
  			locked = lruvec;

  
  			lruvec_memcg_debug(lruvec, page);

  			/* Try get exclusive access under lock */
  			if (!skip_updated) {
  				skip_updated = true;
  				if (test_and_set_skip(cc, page, low_pfn))
  					goto isolate_abort;
  			}

  			/*
  			 * Page become compound since the non-locked check,
  			 * and it's on LRU. It can only be a THP so the order
  			 * is safe to read and it's 0 for tail pages.
  			 */

  			if (unlikely(PageCompound(page) && !cc->alloc_contig)) {

  				low_pfn += compound_nr(page) - 1;

  				SetPageLRU(page);
  				goto isolate_fail_put;

  			}

  		}

  		/* The whole page is taken off the LRU; skip the tail pages. */
  		if (PageCompound(page))
  			low_pfn += compound_nr(page) - 1;

  		/* Successfully isolated */

  		del_page_from_lru_list(page, lruvec);

  		mod_node_page_state(page_pgdat(page),

  				NR_ISOLATED_ANON + page_is_file_lru(page),

  				thp_nr_pages(page));

  
  isolate_success:

  		list_add(&page->lru, &cc->migratepages);

  isolate_success_no_list:

  		cc->nr_migratepages += compound_nr(page);
  		nr_isolated += compound_nr(page);

  		/*
  		 * Avoid isolating too much unless this block is being

  		 * rescanned (e.g. dirty/writeback pages, parallel allocation)
  		 * or a lock is contended. For contention, isolate quickly to
  		 * potentially remove one source of contention.

  		 */

  		if (cc->nr_migratepages >= COMPACT_CLUSTER_MAX &&

  		    !cc->rescan && !cc->contended) {

  			++low_pfn;

  			break;

  		}

  
  		continue;

  
  isolate_fail_put:
  		/* Avoid potential deadlock in freeing page under lru_lock */
  		if (locked) {

  			unlock_page_lruvec_irqrestore(locked, flags);
  			locked = NULL;

  		}
  		put_page(page);

  isolate_fail:

  		if (!skip_on_failure && ret != -ENOMEM)

  			continue;
  
  		/*
  		 * We have isolated some pages, but then failed. Release them
  		 * instead of migrating, as we cannot form the cc->order buddy
  		 * page anyway.
  		 */
  		if (nr_isolated) {
  			if (locked) {

  				unlock_page_lruvec_irqrestore(locked, flags);
  				locked = NULL;

  			}

  			putback_movable_pages(&cc->migratepages);
  			cc->nr_migratepages = 0;

  			nr_isolated = 0;
  		}
  
  		if (low_pfn < next_skip_pfn) {
  			low_pfn = next_skip_pfn - 1;
  			/*
  			 * The check near the loop beginning would have updated
  			 * next_skip_pfn too, but this is a bit simpler.
  			 */
  			next_skip_pfn += 1UL << cc->order;
  		}

  
  		if (ret == -ENOMEM)
  			break;

  	}

  	/*
  	 * The PageBuddy() check could have potentially brought us outside
  	 * the range to be scanned.
  	 */
  	if (unlikely(low_pfn > end_pfn))
  		low_pfn = end_pfn;

  	page = NULL;

  isolate_abort:

  	if (locked)

  		unlock_page_lruvec_irqrestore(locked, flags);

  	if (page) {
  		SetPageLRU(page);
  		put_page(page);
  	}

  	/*

  	 * Updated the cached scanner pfn once the pageblock has been scanned
  	 * Pages will either be migrated in which case there is no point
  	 * scanning in the near future or migration failed in which case the
  	 * failure reason may persist. The block is marked for skipping if
  	 * there were no pages isolated in the block or if the block is
  	 * rescanned twice in a row.

  	 */

  	if (low_pfn == end_pfn && (!nr_isolated || cc->rescan)) {

  		if (valid_page && !skip_updated)
  			set_pageblock_skip(valid_page);
  		update_cached_migrate(cc, low_pfn);
  	}

  	trace_mm_compaction_isolate_migratepages(start_pfn, low_pfn,
  						nr_scanned, nr_isolated);

  fatal_pending:

  	cc->total_migrate_scanned += nr_scanned;

  	if (nr_isolated)

  		count_compact_events(COMPACTISOLATED, nr_isolated);

  	cc->migrate_pfn = low_pfn;
  
  	return ret;

  }

  /**
   * isolate_migratepages_range() - isolate migrate-able pages in a PFN range
   * @cc:        Compaction control structure.
   * @start_pfn: The first PFN to start isolating.
   * @end_pfn:   The one-past-last PFN.
   *

   * Returns -EAGAIN when contented, -EINTR in case of a signal pending, -ENOMEM
   * in case we could not allocate a page, or 0.

   */

  int

  isolate_migratepages_range(struct compact_control *cc, unsigned long start_pfn,
  							unsigned long end_pfn)
  {

  	unsigned long pfn, block_start_pfn, block_end_pfn;

  	int ret = 0;

  
  	/* Scan block by block. First and last block may be incomplete */
  	pfn = start_pfn;

  	block_start_pfn = pageblock_start_pfn(pfn);

  	if (block_start_pfn < cc->zone->zone_start_pfn)
  		block_start_pfn = cc->zone->zone_start_pfn;

  	block_end_pfn = pageblock_end_pfn(pfn);

  
  	for (; pfn < end_pfn; pfn = block_end_pfn,

  				block_start_pfn = block_end_pfn,

  				block_end_pfn += pageblock_nr_pages) {
  
  		block_end_pfn = min(block_end_pfn, end_pfn);

  		if (!pageblock_pfn_to_page(block_start_pfn,
  					block_end_pfn, cc->zone))

  			continue;

  		ret = isolate_migratepages_block(cc, pfn, block_end_pfn,
  						 ISOLATE_UNEVICTABLE);

  		if (ret)

  			break;

  		if (cc->nr_migratepages >= COMPACT_CLUSTER_MAX)

  			break;

  	}

  	return ret;

  }

  #endif /* CONFIG_COMPACTION || CONFIG_CMA */
  #ifdef CONFIG_COMPACTION

  static bool suitable_migration_source(struct compact_control *cc,
  							struct page *page)
  {

  	int block_mt;

  	if (pageblock_skip_persistent(page))
  		return false;

  	if ((cc->mode != MIGRATE_ASYNC) || !cc->direct_compaction)

  		return true;

  	block_mt = get_pageblock_migratetype(page);
  
  	if (cc->migratetype == MIGRATE_MOVABLE)
  		return is_migrate_movable(block_mt);
  	else
  		return block_mt == cc->migratetype;

  }

  /* Returns true if the page is within a block suitable for migration to */

  static bool suitable_migration_target(struct compact_control *cc,
  							struct page *page)

  {
  	/* If the page is a large free page, then disallow migration */
  	if (PageBuddy(page)) {
  		/*
  		 * We are checking page_order without zone->lock taken. But
  		 * the only small danger is that we skip a potentially suitable
  		 * pageblock, so it's not worth to check order for valid range.
  		 */

  		if (buddy_order_unsafe(page) >= pageblock_order)

  			return false;
  	}

  	if (cc->ignore_block_suitable)
  		return true;

  	/* If the block is MIGRATE_MOVABLE or MIGRATE_CMA, allow migration */

  	if (is_migrate_movable(get_pageblock_migratetype(page)))

  		return true;
  
  	/* Otherwise skip the block */
  	return false;
  }

  static inline unsigned int
  freelist_scan_limit(struct compact_control *cc)
  {

  	unsigned short shift = BITS_PER_LONG - 1;
  
  	return (COMPACT_CLUSTER_MAX >> min(shift, cc->fast_search_fail)) + 1;

  }

  /*

   * Test whether the free scanner has reached the same or lower pageblock than
   * the migration scanner, and compaction should thus terminate.
   */
  static inline bool compact_scanners_met(struct compact_control *cc)
  {
  	return (cc->free_pfn >> pageblock_order)
  		<= (cc->migrate_pfn >> pageblock_order);
  }

  /*
   * Used when scanning for a suitable migration target which scans freelists
   * in reverse. Reorders the list such as the unscanned pages are scanned
   * first on the next iteration of the free scanner
   */
  static void
  move_freelist_head(struct list_head *freelist, struct page *freepage)
  {
  	LIST_HEAD(sublist);
  
  	if (!list_is_last(freelist, &freepage->lru)) {
  		list_cut_before(&sublist, freelist, &freepage->lru);

  		list_splice_tail(&sublist, freelist);

  	}
  }
  
  /*
   * Similar to move_freelist_head except used by the migration scanner
   * when scanning forward. It's possible for these list operations to
   * move against each other if they search the free list exactly in
   * lockstep.
   */

  static void
  move_freelist_tail(struct list_head *freelist, struct page *freepage)
  {
  	LIST_HEAD(sublist);
  
  	if (!list_is_first(freelist, &freepage->lru)) {
  		list_cut_position(&sublist, freelist, &freepage->lru);

  		list_splice_tail(&sublist, freelist);

  	}
  }

  static void
  fast_isolate_around(struct compact_control *cc, unsigned long pfn, unsigned long nr_isolated)
  {
  	unsigned long start_pfn, end_pfn;

  	struct page *page;

  
  	/* Do not search around if there are enough pages already */
  	if (cc->nr_freepages >= cc->nr_migratepages)
  		return;
  
  	/* Minimise scanning during async compaction */
  	if (cc->direct_compaction && cc->mode == MIGRATE_ASYNC)
  		return;
  
  	/* Pageblock boundaries */

  	start_pfn = max(pageblock_start_pfn(pfn), cc->zone->zone_start_pfn);
  	end_pfn = min(pageblock_end_pfn(pfn), zone_end_pfn(cc->zone));
  
  	page = pageblock_pfn_to_page(start_pfn, end_pfn, cc->zone);
  	if (!page)
  		return;

  
  	/* Scan before */
  	if (start_pfn != pfn) {

  		isolate_freepages_block(cc, &start_pfn, pfn, &cc->freepages, 1, false);

  		if (cc->nr_freepages >= cc->nr_migratepages)
  			return;
  	}
  
  	/* Scan after */
  	start_pfn = pfn + nr_isolated;

  	if (start_pfn < end_pfn)

  		isolate_freepages_block(cc, &start_pfn, end_pfn, &cc->freepages, 1, false);

  
  	/* Skip this pageblock in the future as it's full or nearly full */
  	if (cc->nr_freepages < cc->nr_migratepages)
  		set_pageblock_skip(page);
  }

  /* Search orders in round-robin fashion */
  static int next_search_order(struct compact_control *cc, int order)
  {
  	order--;
  	if (order < 0)
  		order = cc->order - 1;
  
  	/* Search wrapped around? */
  	if (order == cc->search_order) {
  		cc->search_order--;
  		if (cc->search_order < 0)
  			cc->search_order = cc->order - 1;
  		return -1;
  	}
  
  	return order;
  }

  static unsigned long
  fast_isolate_freepages(struct compact_control *cc)
  {

  	unsigned int limit = max(1U, freelist_scan_limit(cc) >> 1);

  	unsigned int nr_scanned = 0;

  	unsigned long low_pfn, min_pfn, highest = 0;

  	unsigned long nr_isolated = 0;
  	unsigned long distance;
  	struct page *page = NULL;
  	bool scan_start = false;
  	int order;
  
  	/* Full compaction passes in a negative order */
  	if (cc->order <= 0)
  		return cc->free_pfn;
  
  	/*
  	 * If starting the scan, use a deeper search and use the highest
  	 * PFN found if a suitable one is not found.
  	 */

  	if (cc->free_pfn >= cc->zone->compact_init_free_pfn) {

  		limit = pageblock_nr_pages >> 1;
  		scan_start = true;
  	}
  
  	/*
  	 * Preferred point is in the top quarter of the scan space but take
  	 * a pfn from the top half if the search is problematic.
  	 */
  	distance = (cc->free_pfn - cc->migrate_pfn);
  	low_pfn = pageblock_start_pfn(cc->free_pfn - (distance >> 2));
  	min_pfn = pageblock_start_pfn(cc->free_pfn - (distance >> 1));
  
  	if (WARN_ON_ONCE(min_pfn > low_pfn))
  		low_pfn = min_pfn;

  	/*
  	 * Search starts from the last successful isolation order or the next
  	 * order to search after a previous failure
  	 */
  	cc->search_order = min_t(unsigned int, cc->order - 1, cc->search_order);
  
  	for (order = cc->search_order;
  	     !page && order >= 0;
  	     order = next_search_order(cc, order)) {

  		struct free_area *area = &cc->zone->free_area[order];
  		struct list_head *freelist;
  		struct page *freepage;
  		unsigned long flags;
  		unsigned int order_scanned = 0;

  		unsigned long high_pfn = 0;

  
  		if (!area->nr_free)
  			continue;
  
  		spin_lock_irqsave(&cc->zone->lock, flags);
  		freelist = &area->free_list[MIGRATE_MOVABLE];
  		list_for_each_entry_reverse(freepage, freelist, lru) {
  			unsigned long pfn;
  
  			order_scanned++;
  			nr_scanned++;
  			pfn = page_to_pfn(freepage);
  
  			if (pfn >= highest)

  				highest = max(pageblock_start_pfn(pfn),
  					      cc->zone->zone_start_pfn);

  
  			if (pfn >= low_pfn) {
  				cc->fast_search_fail = 0;

  				cc->search_order = order;

  				page = freepage;
  				break;
  			}
  
  			if (pfn >= min_pfn && pfn > high_pfn) {
  				high_pfn = pfn;
  
  				/* Shorten the scan if a candidate is found */
  				limit >>= 1;
  			}
  
  			if (order_scanned >= limit)
  				break;
  		}
  
  		/* Use a minimum pfn if a preferred one was not found */
  		if (!page && high_pfn) {
  			page = pfn_to_page(high_pfn);
  
  			/* Update freepage for the list reorder below */
  			freepage = page;
  		}
  
  		/* Reorder to so a future search skips recent pages */
  		move_freelist_head(freelist, freepage);
  
  		/* Isolate the page if available */
  		if (page) {
  			if (__isolate_free_page(page, order)) {
  				set_page_private(page, order);
  				nr_isolated = 1 << order;
  				cc->nr_freepages += nr_isolated;
  				list_add_tail(&page->lru, &cc->freepages);
  				count_compact_events(COMPACTISOLATED, nr_isolated);
  			} else {
  				/* If isolation fails, abort the search */

  				order = cc->search_order + 1;

  				page = NULL;
  			}
  		}
  
  		spin_unlock_irqrestore(&cc->zone->lock, flags);
  
  		/*

  		 * Smaller scan on next order so the total scan is related

  		 * to freelist_scan_limit.
  		 */
  		if (order_scanned >= limit)

  			limit = max(1U, limit >> 1);

  	}
  
  	if (!page) {
  		cc->fast_search_fail++;
  		if (scan_start) {
  			/*
  			 * Use the highest PFN found above min. If one was

  			 * not found, be pessimistic for direct compaction

  			 * and use the min mark.
  			 */
  			if (highest) {
  				page = pfn_to_page(highest);
  				cc->free_pfn = highest;
  			} else {

  				if (cc->direct_compaction && pfn_valid(min_pfn)) {

  					page = pageblock_pfn_to_page(min_pfn,

  						min(pageblock_end_pfn(min_pfn),
  						    zone_end_pfn(cc->zone)),

  						cc->zone);

  					cc->free_pfn = min_pfn;
  				}
  			}
  		}
  	}

  	if (highest && highest >= cc->zone->compact_cached_free_pfn) {
  		highest -= pageblock_nr_pages;

  		cc->zone->compact_cached_free_pfn = highest;

  	}

  
  	cc->total_free_scanned += nr_scanned;
  	if (!page)
  		return cc->free_pfn;
  
  	low_pfn = page_to_pfn(page);
  	fast_isolate_around(cc, low_pfn, nr_isolated);
  	return low_pfn;
  }

  /*

   * Based on information in the current compact_control, find blocks
   * suitable for isolating free pages from and then isolate them.

   */

  static void isolate_freepages(struct compact_control *cc)

  {

  	struct zone *zone = cc->zone;

  	struct page *page;

  	unsigned long block_start_pfn;	/* start of current pageblock */

  	unsigned long isolate_start_pfn; /* exact pfn we start at */

  	unsigned long block_end_pfn;	/* end of current pageblock */
  	unsigned long low_pfn;	     /* lowest pfn scanner is able to scan */

  	struct list_head *freelist = &cc->freepages;

  	unsigned int stride;

  	/* Try a small search of the free lists for a candidate */
  	isolate_start_pfn = fast_isolate_freepages(cc);
  	if (cc->nr_freepages)
  		goto splitmap;

  	/*
  	 * Initialise the free scanner. The starting point is where we last

  	 * successfully isolated from, zone-cached value, or the end of the

  	 * zone when isolating for the first time. For looping we also need
  	 * this pfn aligned down to the pageblock boundary, because we do

  	 * block_start_pfn -= pageblock_nr_pages in the for loop.
  	 * For ending point, take care when isolating in last pageblock of a

  	 * zone which ends in the middle of a pageblock.

  	 * The low boundary is the end of the pageblock the migration scanner
  	 * is using.

  	 */

  	isolate_start_pfn = cc->free_pfn;

  	block_start_pfn = pageblock_start_pfn(isolate_start_pfn);

  	block_end_pfn = min(block_start_pfn + pageblock_nr_pages,
  						zone_end_pfn(zone));

  	low_pfn = pageblock_end_pfn(cc->migrate_pfn);

  	stride = cc->mode == MIGRATE_ASYNC ? COMPACT_CLUSTER_MAX : 1;

  	/*

  	 * Isolate free pages until enough are available to migrate the
  	 * pages on cc->migratepages. We stop searching if the migrate
  	 * and free page scanners meet or enough free pages are isolated.
  	 */

  	for (; block_start_pfn >= low_pfn;

  				block_end_pfn = block_start_pfn,

  				block_start_pfn -= pageblock_nr_pages,
  				isolate_start_pfn = block_start_pfn) {

  		unsigned long nr_isolated;

  		/*
  		 * This can iterate a massively long zone without finding any

  		 * suitable migration targets, so periodically check resched.

  		 */

  		if (!(block_start_pfn % (SWAP_CLUSTER_MAX * pageblock_nr_pages)))

  			cond_resched();

  		page = pageblock_pfn_to_page(block_start_pfn, block_end_pfn,
  									zone);
  		if (!page)

  			continue;
  
  		/* Check the block is suitable for migration */

  		if (!suitable_migration_target(cc, page))

  			continue;

  		/* If isolation recently failed, do not retry */
  		if (!isolation_suitable(cc, page))
  			continue;

  		/* Found a block suitable for isolating free pages from. */

  		nr_isolated = isolate_freepages_block(cc, &isolate_start_pfn,
  					block_end_pfn, freelist, stride, false);

  		/* Update the skip hint if the full pageblock was scanned */
  		if (isolate_start_pfn == block_end_pfn)
  			update_pageblock_skip(cc, page, block_start_pfn);

  		/* Are enough freepages isolated? */
  		if (cc->nr_freepages >= cc->nr_migratepages) {

  			if (isolate_start_pfn >= block_end_pfn) {
  				/*
  				 * Restart at previous pageblock if more
  				 * freepages can be isolated next time.
  				 */

  				isolate_start_pfn =
  					block_start_pfn - pageblock_nr_pages;

  			}

  			break;

  		} else if (isolate_start_pfn < block_end_pfn) {

  			/*

  			 * If isolation failed early, do not continue
  			 * needlessly.

  			 */

  			break;

  		}

  
  		/* Adjust stride depending on isolation */
  		if (nr_isolated) {
  			stride = 1;
  			continue;
  		}
  		stride = min_t(unsigned int, COMPACT_CLUSTER_MAX, stride << 1);

  	}

  	/*

  	 * Record where the free scanner will restart next time. Either we
  	 * broke from the loop and set isolate_start_pfn based on the last
  	 * call to isolate_freepages_block(), or we met the migration scanner
  	 * and the loop terminated due to isolate_start_pfn < low_pfn

  	 */

  	cc->free_pfn = isolate_start_pfn;

  
  splitmap:
  	/* __isolate_free_page() does not map the pages */
  	split_map_pages(freelist);

  }
  
  /*
   * This is a migrate-callback that "allocates" freepages by taking pages
   * from the isolated freelists in the block we are migrating to.
   */
  static struct page *compaction_alloc(struct page *migratepage,

  					unsigned long data)

  {
  	struct compact_control *cc = (struct compact_control *)data;
  	struct page *freepage;

  	if (list_empty(&cc->freepages)) {

  		isolate_freepages(cc);

  
  		if (list_empty(&cc->freepages))
  			return NULL;
  	}
  
  	freepage = list_entry(cc->freepages.next, struct page, lru);
  	list_del(&freepage->lru);
  	cc->nr_freepages--;
  
  	return freepage;
  }
  
  /*

   * This is a migrate-callback that "frees" freepages back to the isolated
   * freelist.  All pages on the freelist are from the same zone, so there is no
   * special handling needed for NUMA.
   */
  static void compaction_free(struct page *page, unsigned long data)
  {
  	struct compact_control *cc = (struct compact_control *)data;
  
  	list_add(&page->lru, &cc->freepages);
  	cc->nr_freepages++;
  }

  /* possible outcome of isolate_migratepages */
  typedef enum {
  	ISOLATE_ABORT,		/* Abort compaction now */
  	ISOLATE_NONE,		/* No pages isolated, continue scanning */
  	ISOLATE_SUCCESS,	/* Pages isolated, migrate */
  } isolate_migrate_t;
  
  /*

   * Allow userspace to control policy on scanning the unevictable LRU for
   * compactable pages.
   */

  #ifdef CONFIG_PREEMPT_RT
  int sysctl_compact_unevictable_allowed __read_mostly = 0;
  #else

  int sysctl_compact_unevictable_allowed __read_mostly = 1;

  #endif

  static inline void
  update_fast_start_pfn(struct compact_control *cc, unsigned long pfn)
  {
  	if (cc->fast_start_pfn == ULONG_MAX)
  		return;
  
  	if (!cc->fast_start_pfn)
  		cc->fast_start_pfn = pfn;
  
  	cc->fast_start_pfn = min(cc->fast_start_pfn, pfn);
  }
  
  static inline unsigned long
  reinit_migrate_pfn(struct compact_control *cc)
  {
  	if (!cc->fast_start_pfn || cc->fast_start_pfn == ULONG_MAX)
  		return cc->migrate_pfn;
  
  	cc->migrate_pfn = cc->fast_start_pfn;
  	cc->fast_start_pfn = ULONG_MAX;
  
  	return cc->migrate_pfn;
  }
  
  /*
   * Briefly search the free lists for a migration source that already has
   * some free pages to reduce the number of pages that need migration
   * before a pageblock is free.
   */
  static unsigned long fast_find_migrateblock(struct compact_control *cc)
  {
  	unsigned int limit = freelist_scan_limit(cc);
  	unsigned int nr_scanned = 0;
  	unsigned long distance;
  	unsigned long pfn = cc->migrate_pfn;
  	unsigned long high_pfn;
  	int order;

  	bool found_block = false;

  
  	/* Skip hints are relied on to avoid repeats on the fast search */
  	if (cc->ignore_skip_hint)
  		return pfn;
  
  	/*
  	 * If the migrate_pfn is not at the start of a zone or the start
  	 * of a pageblock then assume this is a continuation of a previous
  	 * scan restarted due to COMPACT_CLUSTER_MAX.
  	 */
  	if (pfn != cc->zone->zone_start_pfn && pfn != pageblock_start_pfn(pfn))
  		return pfn;
  
  	/*
  	 * For smaller orders, just linearly scan as the number of pages
  	 * to migrate should be relatively small and does not necessarily
  	 * justify freeing up a large block for a small allocation.
  	 */
  	if (cc->order <= PAGE_ALLOC_COSTLY_ORDER)
  		return pfn;
  
  	/*
  	 * Only allow kcompactd and direct requests for movable pages to
  	 * quickly clear out a MOVABLE pageblock for allocation. This
  	 * reduces the risk that a large movable pageblock is freed for
  	 * an unmovable/reclaimable small allocation.
  	 */
  	if (cc->direct_compaction && cc->migratetype != MIGRATE_MOVABLE)
  		return pfn;
  
  	/*
  	 * When starting the migration scanner, pick any pageblock within the
  	 * first half of the search space. Otherwise try and pick a pageblock
  	 * within the first eighth to reduce the chances that a migration
  	 * target later becomes a source.
  	 */
  	distance = (cc->free_pfn - cc->migrate_pfn) >> 1;
  	if (cc->migrate_pfn != cc->zone->zone_start_pfn)
  		distance >>= 2;
  	high_pfn = pageblock_start_pfn(cc->migrate_pfn + distance);
  
  	for (order = cc->order - 1;

  	     order >= PAGE_ALLOC_COSTLY_ORDER && !found_block && nr_scanned < limit;

  	     order--) {
  		struct free_area *area = &cc->zone->free_area[order];
  		struct list_head *freelist;
  		unsigned long flags;
  		struct page *freepage;
  
  		if (!area->nr_free)
  			continue;
  
  		spin_lock_irqsave(&cc->zone->lock, flags);
  		freelist = &area->free_list[MIGRATE_MOVABLE];
  		list_for_each_entry(freepage, freelist, lru) {
  			unsigned long free_pfn;

  			if (nr_scanned++ >= limit) {
  				move_freelist_tail(freelist, freepage);
  				break;
  			}

  			free_pfn = page_to_pfn(freepage);
  			if (free_pfn < high_pfn) {

  				/*
  				 * Avoid if skipped recently. Ideally it would
  				 * move to the tail but even safe iteration of
  				 * the list assumes an entry is deleted, not
  				 * reordered.
  				 */

  				if (get_pageblock_skip(freepage))

  					continue;

  
  				/* Reorder to so a future search skips recent pages */
  				move_freelist_tail(freelist, freepage);

  				update_fast_start_pfn(cc, free_pfn);

  				pfn = pageblock_start_pfn(free_pfn);

  				if (pfn < cc->zone->zone_start_pfn)
  					pfn = cc->zone->zone_start_pfn;

  				cc->fast_search_fail = 0;

  				found_block = true;

  				set_pageblock_skip(freepage);
  				break;
  			}

  		}
  		spin_unlock_irqrestore(&cc->zone->lock, flags);
  	}
  
  	cc->total_migrate_scanned += nr_scanned;
  
  	/*
  	 * If fast scanning failed then use a cached entry for a page block
  	 * that had free pages as the basis for starting a linear scan.
  	 */

  	if (!found_block) {
  		cc->fast_search_fail++;

  		pfn = reinit_migrate_pfn(cc);

  	}

  	return pfn;
  }

  /*

   * Isolate all pages that can be migrated from the first suitable block,
   * starting at the block pointed to by the migrate scanner pfn within
   * compact_control.

   */

  static isolate_migrate_t isolate_migratepages(struct compact_control *cc)

  {

  	unsigned long block_start_pfn;
  	unsigned long block_end_pfn;
  	unsigned long low_pfn;

  	struct page *page;
  	const isolate_mode_t isolate_mode =

  		(sysctl_compact_unevictable_allowed ? ISOLATE_UNEVICTABLE : 0) |

  		(cc->mode != MIGRATE_SYNC ? ISOLATE_ASYNC_MIGRATE : 0);

  	bool fast_find_block;

  	/*
  	 * Start at where we last stopped, or beginning of the zone as

  	 * initialized by compact_zone(). The first failure will use
  	 * the lowest PFN as the starting point for linear scanning.

  	 */