From 65d759c8f9f57b96c199f3fe5cfb93ac7da095e9 Mon Sep 17 00:00:00 2001

From: Charan Teja Reddy <charante@codeaurora.org>

Date: Thu, 2 Sep 2021 14:59:59 -0700

Subject: [PATCH] mm: compaction: support triggering of proactive compaction by

 user

References: bsc#1207010

Git-commit: 65d759c8f9f57b96c199f3fe5cfb93ac7da095e9

Patch-mainline: v5.15-rc1

The proactive compaction[1] gets triggered for every 500msec and run

compaction on the node for COMPACTION_HPAGE_ORDER (usually order-9) pages

based on the value set to sysctl.compaction_proactiveness.  Triggering the

compaction for every 500msec in search of COMPACTION_HPAGE_ORDER pages is

not needed for all applications, especially on the embedded system

usecases which may have few MB's of RAM.  Enabling the proactive

compaction in its state will endup in running almost always on such

systems.

Other side, proactive compaction can still be very much useful for getting

a set of higher order pages in some controllable manner(controlled by

using the sysctl.compaction_proactiveness).  So, on systems where enabling

the proactive compaction always may proove not required, can trigger the

same from user space on write to its sysctl interface.  As an example, say

app launcher decide to launch the memory heavy application which can be

launched fast if it gets more higher order pages thus launcher can prepare

the system in advance by triggering the proactive compaction from

userspace.

This triggering of proactive compaction is done on a write to

sysctl.compaction_proactiveness by user.

[1]https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit?id=facdaa917c4d5a376d09d25865f5a863f906234a

[akpm@linux-foundation.org: tweak vm.rst, per Mike]

Link: https://lkml.kernel.org/r/1627653207-12317-1-git-send-email-charante@codeaurora.org

Signed-off-by: Charan Teja Reddy <charante@codeaurora.org>

Acked-by: Vlastimil Babka <vbabka@suse.cz>

Acked-by: Rafael Aquini <aquini@redhat.com>

Cc: Mike Rapoport <rppt@kernel.org>

Cc: Luis Chamberlain <mcgrof@kernel.org>

Cc: Kees Cook <keescook@chromium.org>

Cc: Iurii Zaikin <yzaikin@google.com>

Cc: Dave Hansen <dave.hansen@linux.intel.com>

Cc: Mel Gorman <mgorman@techsingularity.net>

Cc: Nitin Gupta <nigupta@nvidia.com>

Cc: Jonathan Corbet <corbet@lwn.net>

Cc: Khalid Aziz <khalid.aziz@oracle.com>

Cc: David Rientjes <rientjes@google.com>

Cc: Vinayak Menon <vinmenon@codeaurora.org>

Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Signed-off-by: Thomas Abraham <tabraham@suse.com>

---

 Documentation/admin-guide/sysctl/vm.rst |  3 +-

 include/linux/compaction.h              |  2 ++

 include/linux/mmzone.h                  |  1 +

 kernel/sysctl.c                         |  2 +-

 mm/compaction.c                         | 38 +++++++++++++++++++++++--

 5 files changed, 42 insertions(+), 4 deletions(-)

diff --git a/Documentation/admin-guide/sysctl/vm.rst b/Documentation/admin-guide/sysctl/vm.rst

index 003d5cc3751b..5e795202111f 100644

--- a/Documentation/admin-guide/sysctl/vm.rst

+++ b/Documentation/admin-guide/sysctl/vm.rst

@@ -118,7 +118,8 @@ compaction_proactiveness

 This tunable takes a value in the range [0, 100] with a default value of

 20. This tunable determines how aggressively compaction is done in the

-background. Setting it to 0 disables proactive compaction.

+background. Write of a non zero value to this tunable will immediately

+trigger the proactive compaction. Setting it to 0 disables proactive compaction.

 Note that compaction has a non-trivial system-wide impact as pages

 belonging to different processes are moved around, which could also lead

diff --git a/include/linux/compaction.h b/include/linux/compaction.h

index c24098c7acca..34bce35c808d 100644

--- a/include/linux/compaction.h

+++ b/include/linux/compaction.h

@@ -84,6 +84,8 @@ static inline unsigned long compact_gap(unsigned int order)

 extern unsigned int sysctl_compaction_proactiveness;

 extern int sysctl_compaction_handler(struct ctl_table *table, int write,

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

+extern int compaction_proactiveness_sysctl_handler(struct ctl_table *table,

+		int write, void *buffer, size_t *length, loff_t *ppos);

 extern int sysctl_extfrag_threshold;

 extern int sysctl_compact_unevictable_allowed;

diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h

index 59bad25ce78e..1bd5f5955f9a 100644

--- a/include/linux/mmzone.h

+++ b/include/linux/mmzone.h

@@ -846,6 +846,7 @@ typedef struct pglist_data {

 	enum zone_type kcompactd_highest_zoneidx;

 	wait_queue_head_t kcompactd_wait;

 	struct task_struct *kcompactd;

+	bool proactive_compact_trigger;

 #endif

 	/*

 	 * This is a per-node reserve of pages that are not available

diff --git a/kernel/sysctl.c b/kernel/sysctl.c

index 272f4a272f8c..297f0b3966bd 100644

--- a/kernel/sysctl.c

+++ b/kernel/sysctl.c

@@ -2871,7 +2871,7 @@ static struct ctl_table vm_table[] = {

 		.data		= &sysctl_compaction_proactiveness,

 		.maxlen		= sizeof(sysctl_compaction_proactiveness),

 		.mode		= 0644,

-		.proc_handler	= proc_dointvec_minmax,

+		.proc_handler	= compaction_proactiveness_sysctl_handler,

 		.extra1		= SYSCTL_ZERO,

 		.extra2		= &one_hundred,

 	},

diff --git a/mm/compaction.c b/mm/compaction.c

index 4ee0d40d93f2..fa9b2b598eab 100644

--- a/mm/compaction.c

+++ b/mm/compaction.c

@@ -2706,6 +2706,30 @@ static void compact_nodes(void)

  */

 unsigned int __read_mostly sysctl_compaction_proactiveness = 20;

+int compaction_proactiveness_sysctl_handler(struct ctl_table *table, int write,

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

+{

+	int rc, nid;

+

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

+	if (rc)

+		return rc;

+

+	if (write && sysctl_compaction_proactiveness) {

+		for_each_online_node(nid) {

+			pg_data_t *pgdat = NODE_DATA(nid);

+

+			if (pgdat->proactive_compact_trigger)

+				continue;

+

+			pgdat->proactive_compact_trigger = true;

+			wake_up_interruptible(&pgdat->kcompactd_wait);

+		}

+	}

+

+	return 0;

+}

+

 /*

  * This is the entry point for compacting all nodes via

  * /proc/sys/vm/compact_memory

@@ -2750,7 +2774,8 @@ void compaction_unregister_node(struct node *node)

 static inline bool kcompactd_work_requested(pg_data_t *pgdat)

 {

-	return pgdat->kcompactd_max_order > 0 || kthread_should_stop();

+	return pgdat->kcompactd_max_order > 0 || kthread_should_stop() ||

+		pgdat->proactive_compact_trigger;

 }

 static bool kcompactd_node_suitable(pg_data_t *pgdat)

@@ -2901,9 +2926,16 @@ static int kcompactd(void *p)

 	while (!kthread_should_stop()) {

 		unsigned long pflags;

+		/*

+		 * Avoid the unnecessary wakeup for proactive compaction

+		 * when it is disabled.

+		 */

+		if (!sysctl_compaction_proactiveness)

+			timeout = MAX_SCHEDULE_TIMEOUT;

 		trace_mm_compaction_kcompactd_sleep(pgdat->node_id);

 		if (wait_event_freezable_timeout(pgdat->kcompactd_wait,

-			kcompactd_work_requested(pgdat), timeout)) {

+			kcompactd_work_requested(pgdat), timeout) &&

+			!pgdat->proactive_compact_trigger) {

 			psi_memstall_enter(&pflags);

 			kcompactd_do_work(pgdat);

@@ -2938,6 +2970,8 @@ static int kcompactd(void *p)

 				timeout =

 				   default_timeout << COMPACT_MAX_DEFER_SHIFT;

 		}

+		if (unlikely(pgdat->proactive_compact_trigger))

+			pgdat->proactive_compact_trigger = false;

 	}

 	return 0;

-- 

2.35.3