| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Date: Tue, 25 May 2021 19:50:51 +0530
From: Charan Teja Kalla <charante@...eaurora.org>
To: akpm@...ux-foundation.org, mcgrof@...nel.org,
keescook@...omium.org, yzaikin@...gle.com, vbabka@...e.cz,
nigupta@...dia.com, bhe@...hat.com, mateusznosek0@...il.com,
sh_def@....com, iamjoonsoo.kim@....com, vinmenon@...eaurora.org
Cc: linux-kernel@...r.kernel.org, linux-mm@...ck.org,
linux-fsdevel@...r.kernel.org
Subject: Re: [PATCH V2] mm: compaction: support triggering of proactive
compaction by user
Gentle ping.
Thanks,
Charan
On 5/18/2021 7:07 PM, Charan Teja Reddy wrote:
> 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). Thus 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
>
> Signed-off-by: Charan Teja Reddy <charante@...eaurora.org>
> ---
> changes in V2:
> - remove /proc interface trigger for proactive compaction
> - Intention is same that add a way to trigger proactive compaction by user.
>
> changes in V1:
> - https://lore.kernel.org/lkml/1619098678-8501-1-git-send-email-charante@codeaurora.org/
>
> include/linux/compaction.h | 2 ++
> include/linux/mmzone.h | 1 +
> kernel/sysctl.c | 2 +-
> mm/compaction.c | 35 ++++++++++++++++++++++++++++++++---
> 4 files changed, 36 insertions(+), 4 deletions(-)
>
> diff --git a/include/linux/compaction.h b/include/linux/compaction.h
> index 4221888..04d5d9f 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 0d53eba..9455809 100644
> --- a/include/linux/mmzone.h
> +++ b/include/linux/mmzone.h
> @@ -815,6 +815,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 14edf84..bed2fad 100644
> --- a/kernel/sysctl.c
> +++ b/kernel/sysctl.c
> @@ -2840,7 +2840,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 84fde27..9056693 100644
> --- a/mm/compaction.c
> +++ b/mm/compaction.c
> @@ -2708,6 +2708,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
> @@ -2752,7 +2776,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)
> @@ -2905,7 +2930,8 @@ static int kcompactd(void *p)
> trace_mm_compaction_kcompactd_sleep(pgdat->node_id);
> if (wait_event_freezable_timeout(pgdat->kcompactd_wait,
> kcompactd_work_requested(pgdat),
> - msecs_to_jiffies(HPAGE_FRAG_CHECK_INTERVAL_MSEC))) {
> + msecs_to_jiffies(HPAGE_FRAG_CHECK_INTERVAL_MSEC)) &&
> + !pgdat->proactive_compact_trigger) {
>
> psi_memstall_enter(&pflags);
> kcompactd_do_work(pgdat);
> @@ -2919,7 +2945,7 @@ static int kcompactd(void *p)
>
> if (proactive_defer) {
> proactive_defer--;
> - continue;
> + goto loop;
> }
> prev_score = fragmentation_score_node(pgdat);
> proactive_compact_node(pgdat);
> @@ -2931,6 +2957,9 @@ static int kcompactd(void *p)
> proactive_defer = score < prev_score ?
> 0 : 1 << COMPACT_MAX_DEFER_SHIFT;
> }
> +loop:
> + if (pgdat->proactive_compact_trigger)
> + pgdat->proactive_compact_trigger = false;
> }
>
> return 0;
>
--
The Qualcomm Innovation Center, Inc. is a member of the Code Aurora
Forum, a Linux Foundation Collaborative Project
Powered by blists - more mailing lists