Revert "BACKPORT: mm: reclaim small amounts of memory when an external fragmentation event occurs"

- swappiness

- user_reserve_kbytes

- vfs_cache_pressure

- watermark_boost_factor

- watermark_scale_factor

- zone_reclaim_mode

=============================================================

watermark_boost_factor:

This factor controls the level of reclaim when memory is being fragmented.

It defines the percentage of the high watermark of a zone that will be

reclaimed if pages of different mobility are being mixed within pageblocks.

The intent is that compaction has less work to do in the future and to

increase the success rate of future high-order allocations such as SLUB

allocations, THP and hugetlbfs pages.

To make it sensible with respect to the watermark_scale_factor parameter,

the unit is in fractions of 10,000. The default value of 15,000 means

that up to 150% of the high watermark will be reclaimed in the event of

a pageblock being mixed due to fragmentation. The level of reclaim is

determined by the number of fragmentation events that occurred in the

recent past. If this value is smaller than a pageblock then a pageblocks

worth of pages will be reclaimed (e.g.  2MB on 64-bit x86). A boost factor

of 0 will disable the feature.

=============================================================

watermark_scale_factor:

This factor controls the aggressiveness of kswapd. It defines the

/* page_alloc.c */

extern int min_free_kbytes;

extern int watermark_boost_factor;

extern int watermark_scale_factor;

/* nommu.c */

	NR_WMARK

};

#define min_wmark_pages(z) (z->_watermark[WMARK_MIN] + z->watermark_boost)

#define low_wmark_pages(z) (z->_watermark[WMARK_LOW] + z->watermark_boost)

#define high_wmark_pages(z) (z->_watermark[WMARK_HIGH] + z->watermark_boost)

#define wmark_pages(z, i) (z->_watermark[i] + z->watermark_boost)

#define min_wmark_pages(z) (z->_watermark[WMARK_MIN])

#define low_wmark_pages(z) (z->_watermark[WMARK_LOW])

#define high_wmark_pages(z) (z->_watermark[WMARK_HIGH])

#define wmark_pages(z, i) (z->_watermark[i])

struct per_cpu_pages {

	int count;		/* number of pages in the list */

	/* zone watermarks, access with *_wmark_pages(zone) macros */

	unsigned long _watermark[NR_WMARK];

	unsigned long watermark_boost;

	unsigned long nr_reserved_highatomic;

struct ctl_table;

int min_free_kbytes_sysctl_handler(struct ctl_table *, int,

					void __user *, size_t *, loff_t *);

int watermark_boost_factor_sysctl_handler(struct ctl_table *, int,

					void __user *, size_t *, loff_t *);

int watermark_scale_factor_sysctl_handler(struct ctl_table *, int,

					void __user *, size_t *, loff_t *);

extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES];

		.proc_handler	= min_free_kbytes_sysctl_handler,

		.extra1		= &zero,

	},

	{

		.procname	= "watermark_boost_factor",

		.data		= &watermark_boost_factor,

		.maxlen		= sizeof(watermark_boost_factor),

		.mode		= 0644,

		.proc_handler	= watermark_boost_factor_sysctl_handler,

		.extra1		= &zero,

	},

	{

		.procname	= "watermark_scale_factor",

		.data		= &watermark_scale_factor,

 */

int min_free_kbytes = 1024;

int user_min_free_kbytes = -1;

int watermark_boost_factor __read_mostly = 15000;

int watermark_scale_factor = 10;

/*

	return false;

}

static inline void boost_watermark(struct zone *zone)

{

	unsigned long max_boost;

	if (!watermark_boost_factor)

		return;

	max_boost = mult_frac(zone->_watermark[WMARK_HIGH],

			watermark_boost_factor, 10000);

	max_boost = max(pageblock_nr_pages, max_boost);

	zone->watermark_boost = min(zone->watermark_boost + pageblock_nr_pages,

		max_boost);

}

/*

 * This function implements actual steal behaviour. If order is large enough,

 * we can steal whole pageblock. If not, we first move freepages in this

 * itself, so pages freed in the future will be put on the correct free list.

 */

static void steal_suitable_fallback(struct zone *zone, struct page *page,

		unsigned int alloc_flags, int start_type, bool whole_block)

					int start_type, bool whole_block)

{

	unsigned int current_order = page_order(page);

	struct free_area *area;

		goto single_page;

	}

	/*

	 * Boost watermarks to increase reclaim pressure to reduce the

	 * likelihood of future fallbacks. Wake kswapd now as the node

	 * may be balanced overall and kswapd will not wake naturally.

	 */

	boost_watermark(zone);

	if (alloc_flags & ALLOC_KSWAPD)

		wakeup_kswapd(zone, 0, 0, zone_idx(zone));

	/* We are not allowed to try stealing from the whole block */

	if (!whole_block)

		goto single_page;

	page = list_first_entry(&area->free_list[fallback_mt],

							struct page, lru);

	steal_suitable_fallback(zone, page, alloc_flags, start_migratetype,

								can_steal);

	steal_suitable_fallback(zone, page, start_migratetype, can_steal);

	trace_mm_page_alloc_extfrag(page, order, current_order,

		start_migratetype, fallback_mt);

					low + min;

		zone->_watermark[WMARK_HIGH] = min_wmark_pages(zone) +

					low + min * 2;

		zone->watermark_boost = 0;

		spin_unlock_irqrestore(&zone->lock, flags);

	}

	return 0;

}

int watermark_boost_factor_sysctl_handler(struct ctl_table *table, int write,

	void __user *buffer, size_t *length, loff_t *ppos)

{

	int rc;

	rc = proc_dointvec_minmax(table, write, buffer, length, ppos);

	if (rc)

		return rc;

	return 0;

}

int watermark_scale_factor_sysctl_handler(struct ctl_table *table, int write,

	void __user *buffer, size_t *length, loff_t *ppos)

{