Allow DAMON user code independent of monitoring primitives
Subsystems (2)
SeongJae Park
maintainercover Allow DAMON user code independent of monitoring primitives
In-kernel DAMON user code is required to configure the monitoring context (struct damon_ctx) with proper monitoring primitives (struct damon_primitive). This makes the user code dependent to all supporting monitoring primitives. For example, DAMON debugfs interface depends on both DAMON_VADDR and DAMON_PADDR, though some users have interest in only one use case. As more monitoring primitives are introduced, the problem will be bigger.
To minimize such unnecessary dependency, this patchset makes monitoring primitives can be registered by the implemnting code and later dynamically searched and selected by the user code.
In addition to that, this patchset renames monitoring primitives to monitoring operations, which is more easy to intuitively understand what it means and how it would be structed.
SeongJae Park (8):
mm/damon: Rename damon_primitives to damon_operations mm/damon: Let monitoring operations can be registered and selected mm/damon/paddr,vaddr: Register themselves to DAMON in subsys_initcall mm/damon/reclaim: Use damon_select_ops() instead of
damon_{v,p}a_set_operations()
mm/damon/dbgfs: Use damon_select_ops() instead of
damon_{v,p}a_set_operations()
mm/damon/dbgfs: Use operations id for knowing if the target has pid
mm/damon/dbgfs-test: Fix is_target_id() change
mm/damon/paddr,vaddr: Remove
damon_{p,v}a_{target_valid,set_operations}() include/linux/damon.h | 72 ++++++------
mm/damon/Kconfig | 12 +-
mm/damon/Makefile | 4 +-
mm/damon/core.c | 131 ++++++++++++++++------
mm/damon/dbgfs-test.h | 4 +-
mm/damon/dbgfs.c | 20 +++-
mm/damon/{prmtv-common.c => ops-common.c} | 2 +-
mm/damon/{prmtv-common.h => ops-common.h} | 0
mm/damon/paddr.c | 36 +++---
mm/damon/reclaim.c | 4 +-
mm/damon/vaddr-test.h | 2 +-
mm/damon/vaddr.c | 33 +++---
12 files changed, 209 insertions(+), 111 deletions(-)
rename mm/damon/{prmtv-common.c => ops-common.c} (99%)
rename mm/damon/{prmtv-common.h => ops-common.h} (100%)Signature · 1 line
2.17.1
SeongJae Park
maintainerPATCH 2/8 mm/damon: Let monitoring operations can be registered and selected
In-kernel DAMON user code like DAMON debugfs interface should set 'struct damon_operations' of its 'struct damon_ctx' on its own. Therefore, the client code should depend on all supporting monitoring operations implementations that it could use. For example, DAMON debugfs interface depends on both vaddr and paddr, while some of the users are not always interested in both.
To minimize such unnecessary dependencies, this commit makes the monitoring operations can be registered by implementing code and then dynamically selected by the user code without build-time dependency.
--- include/linux/damon.h | 18 ++++++++++++ mm/damon/core.c | 66 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 84 insertions(+)
include/linux/damon.h +18 -0
@@ -253,11 +253,24 @@ struct damos {struct list_head list; }; +/** +* enum damon_ops_id - Identifier for each monitoring operations implementation +* +* @DAMON_OPS_VADDR: Monitoring operations for virtual address spaces +* @DAMON_OPS_PADDR: Monitoring operations for the physical address space +*/ +enum damon_ops_id { +DAMON_OPS_VADDR , +DAMON_OPS_PADDR , +NR_DAMON_OPS , +}; +struct damon_ctx ;/** * struct damon_operations - Monitoring operations for given use cases. * +* @id: Identifier of this operations set. * @init: Initialize operations-related data structures. * @update: Update operations-related data structures. * @prepare_access_checks: Prepare next access check of target regions.
@@ -277,6 +290,8 @@ struct damon_ctx;* &damon_ctx.sample_interval. Finally, @reset_aggregated is called after each * &damon_ctx.aggr_interval. * +* Each &struct damon_operations instance having valid @id can be registered +* via damon_register_ops() and selected by damon_select_ops() later. * @init should initialize operations-related data structures. For example, * this could be used to construct proper monitoring target regions and link * those to @damon_ctx.adaptive_targets.
@@ -301,6 +316,7 @@ struct damon_ctx;* @cleanup is called from @kdamond just before its termination. */ struct damon_operations { +enum damon_ops_id id;void (*init)(struct damon_ctx *context);void (*update)(struct damon_ctx *context);void (*prepare_access_checks)(struct damon_ctx *context);
@@ -489,6 +505,8 @@ int damon_set_attrs(struct damon_ctx *ctx, unsigned long sample_int,int damon_set_schemes (struct damon_ctx *ctx,struct damos **schemes,ssize_t nr_schemes);int damon_nr_running_ctxs (void ); +int damon_register_ops (struct damon_operations *ops); +int damon_select_ops (struct damon_ctx *ctx,enum damon_ops_id id);int damon_start (struct damon_ctx **ctxs,int nr_ctxs);int damon_stop (struct damon_ctx **ctxs,int nr_ctxs);
mm/damon/core.c +66 -0
72 lines not on this page · raw message
Signature · 1 line
2.17.1
SeongJae Park
maintainerPATCH 3/8 mm/damon/paddr,vaddr: Register themselves to DAMON in subsys_initcall
In reply to SeongJae ParkThis commit makes the monitoring operations for the physical address space and virtual address spaces register themselves to DAMON in the subsys_initcall step. Later, in-kernel DAMON user code can use them via damon_select_ops() without have to unnecessarily depend on all possible monitoring operations implementations.
--- mm/damon/paddr.c | 20 ++++++++++++++++++++ mm/damon/vaddr.c | 20 ++++++++++++++++++++ 2 files changed, 40 insertions(+)
mm/damon/paddr.c +20 -0
@@ -273,3 +273,23 @@ void damon_pa_set_operations(struct damon_ctx *ctx) ctx->ops.apply_scheme = damon_pa_apply_scheme; ctx->ops.get_scheme_score = damon_pa_scheme_score; } + +static int __init damon_pa_initcall (void ) +{ +struct damon_operations ops = { + .id =DAMON_OPS_PADDR , + .init =NULL , + .update =NULL , + .prepare_access_checks = damon_pa_prepare_access_checks, + .check_accesses = damon_pa_check_accesses, + .reset_aggregated =NULL , + .target_valid = damon_pa_target_valid, + .cleanup =NULL , + .apply_scheme = damon_pa_apply_scheme, + .get_scheme_score = damon_pa_scheme_score, + }; + +return damon_register_ops (&ops); +}; + +subsys_initcall (damon_pa_initcall);
mm/damon/vaddr.c +20 -0
@@ -752,4 +752,24 @@ void damon_va_set_operations(struct damon_ctx *ctx) ctx->ops.get_scheme_score = damon_va_scheme_score; } +static int __init damon_va_initcall (void ) +{ +struct damon_operations ops = { + .id =DAMON_OPS_VADDR , + .init = damon_va_init, + .update = damon_va_update, + .prepare_access_checks = damon_va_prepare_access_checks, + .check_accesses = damon_va_check_accesses, + .reset_aggregated =NULL , + .target_valid = damon_va_target_valid, + .cleanup =NULL , + .apply_scheme = damon_va_apply_scheme, + .get_scheme_score = damon_va_scheme_score, + }; + +return damon_register_ops (&ops); +}; + +subsys_initcall (damon_va_initcall); +#include "vaddr-test.h"
Signature · 1 line
2.17.1
SeongJae Park
maintainerPATCH 1/8 mm/damon: Rename damon_primitives to damon_operations
In reply to SeongJae ParkDAMON has a set of callback functions called monitoring primitives and let it can be configured with various implementations for easy extension for different address spaces and usages. However, the word 'primitive' is not so explicit. Meanwhile, many other structs resembles similar purpose calls themselves 'operations'. To make the code easier to be understood, this commit renames 'damon_primitives' to 'damon_operations' before it is too late to rename.
---
include/linux/damon.h | 48 ++++++++---------
mm/damon/Kconfig | 12 ++---
mm/damon/Makefile | 4 +-
mm/damon/core.c | 65 ++++++++++++-----------
mm/damon/dbgfs-test.h | 2 +-
mm/damon/dbgfs.c | 10 ++--
mm/damon/{prmtv-common.c => ops-common.c} | 2 +-
mm/damon/{prmtv-common.h => ops-common.h} | 0
mm/damon/paddr.c | 22 ++++----
mm/damon/reclaim.c | 2 +-
mm/damon/vaddr-test.h | 2 +-
mm/damon/vaddr.c | 22 ++++----
12 files changed, 96 insertions(+), 95 deletions(-)
rename mm/damon/{prmtv-common.c => ops-common.c} (99%)
rename mm/damon/{prmtv-common.h => ops-common.h} (100%)include/linux/damon.h +24 -24
@@ -67,8 +67,8 @@ struct damon_region {* * Each monitoring context could have multiple targets. For example, a context * for virtual memory address spaces could have multiple target processes. The -* @pid should be set for appropriate address space monitoring primitives -* including the virtual address spaces monitoring primitives. +* @pid should be set for appropriate &struct damon_operations including the +* virtual address spaces monitoring operations. */ struct damon_target {struct pid *pid;
@@ -120,9 +120,9 @@ enum damos_action {* uses smaller one as the effective quota. * * For selecting regions within the quota, DAMON prioritizes current scheme's -* target memory regions using the &struct damon_primitive->get_scheme_score. +* target memory regions using the &struct damon_operations->get_scheme_score. * You could customize the prioritization logic by setting &weight_sz, -* &weight_nr_accesses, and &weight_age, because monitoring primitives are +* &weight_nr_accesses, and &weight_age, because monitoring operations are * encouraged to respect those. */ struct damos_quota {
@@ -256,10 +256,10 @@ struct damos {struct damon_ctx ;/** -* struct damon_primitive - Monitoring primitives for given use cases. +* struct damon_operations - Monitoring operations for given use cases. * -* @init: Initialize primitive-internal data structures. -* @update: Update primitive-internal data structures. +* @init: Initialize operations-related data structures. +* @update: Update operations-related data structures. * @prepare_access_checks: Prepare next access check of target regions. * @check_accesses: Check the accesses to target regions. * @reset_aggregated: Reset aggregated accesses monitoring results.
@@ -269,18 +269,18 @@ struct damon_ctx;* @cleanup: Clean up the context. * * DAMON can be extended for various address spaces and usages. For this, -* users should register the low level primitives for their target address -* space and usecase via the &damon_ctx.primitive. Then, the monitoring thread +* users should register the low level operations for their target address +* space and usecase via the &damon_ctx.ops. Then, the monitoring thread * (&damon_ctx.kdamond) calls @init and @prepare_access_checks before starting -* the monitoring, @update after each &damon_ctx.primitive_update_interval, and +* the monitoring, @update after each &damon_ctx.ops_update_interval, and * @check_accesses, @target_valid and @prepare_access_checks after each * &damon_ctx.sample_interval. Finally, @reset_aggregated is called after each * &damon_ctx.aggr_interval. * -* @init should initialize primitive-internal data structures. For example, +* @init should initialize operations-related data structures. For example, * this could be used to construct proper monitoring target regions and link * those to @damon_ctx.adaptive_targets. -* @update should update the primitive-internal data structures. For example, +* @update should update the operations-related data structures. For example, * this could be used to update monitoring target regions for current status. * @prepare_access_checks should manipulate the monitoring regions to be * prepared for the next access check.
@@ -300,7 +300,7 @@ struct damon_ctx;* monitoring. * @cleanup is called from @kdamond just before its termination. */ -struct damon_primitive { +struct damon_operations {void (*init)(struct damon_ctx *context);void (*update)(struct damon_ctx *context);void (*prepare_access_checks)(struct damon_ctx *context);
@@ -354,15 +354,15 @@ struct damon_callback {* * @sample_interval: The time between access samplings. * @aggr_interval: The time between monitor results aggregations. -* @primitive_update_interval: The time between monitoring primitive updates. +* @ops_update_interval: The time between monitoring operations updates. * * For each @sample_interval, DAMON checks whether each region is accessed or * not. It aggregates and keeps the access information (number of accesses to * each region) for @aggr_interval time. DAMON also checks whether the target * memory regions need update (e.g., by ``mmap()`` calls from the application, * in case of virtual memory monitoring) and applies the changes for each -* @primitive_update_interval. All time intervals are in micro-seconds. -* Please refer to &struct damon_primitive and &struct damon_callback for more +* @ops_update_interval. All time intervals are in micro-seconds. +* Please refer to &struct damon_operations and &struct damon_callback for more * detail. * * @kdamond: Kernel thread who does the monitoring.
@@ -374,7 +374,7 @@ struct damon_callback {* * Once started, the monitoring thread runs until explicitly required to be * terminated or every monitoring target is invalid. The validity of the -* targets is checked via the &damon_primitive.target_valid of @primitive. The +* targets is checked via the &damon_operations.target_valid of @ops. The * termination can also be explicitly requested by writing non-zero to * @kdamond_stop. The thread sets @kdamond to NULL when it terminates. * Therefore, users can know whether the monitoring is ongoing or terminated by
@@ -384,7 +384,7 @@ struct damon_callback {* Note that the monitoring thread protects only @kdamond and @kdamond_stop via * @kdamond_lock. Accesses to other fields must be protected by themselves. * -* @primitive: Set of monitoring primitives for given use cases. +* @ops: Set of monitoring operations for given use cases. * @callback: Set of callbacks for monitoring events notifications. * * @min_nr_regions: The minimum number of adaptive monitoring regions.
@@ -395,17 +395,17 @@ struct damon_callback {struct damon_ctx {unsigned long sample_interval;unsigned long aggr_interval; -unsigned long primitive_update_interval; +unsigned long ops_update_interval;/* private: internal use only */ struct timespec64 last_aggregation; -struct timespec64 last_primitive_update; +struct timespec64 last_ops_update;/* public: */ struct task_struct *kdamond;struct mutex kdamond_lock; -struct damon_primitive primitive; +struct damon_operations ops;struct damon_callback callback;unsigned long min_nr_regions;
@@ -484,7 +484,7 @@ unsigned int damon_nr_regions(struct damon_target *t);struct damon_ctx *damon_new_ctx (void );void damon_destroy_ctx (struct damon_ctx *ctx);int damon_set_attrs (struct damon_ctx *ctx,unsigned long sample_int, -unsigned long aggr_int,unsigned long primitive_upd_int, +unsigned long aggr_int,unsigned long ops_upd_int,unsigned long min_nr_reg,unsigned long max_nr_reg);int damon_set_schemes (struct damon_ctx *ctx,struct damos **schemes,ssize_t nr_schemes);
@@ -497,12 +497,12 @@ int damon_stop(struct damon_ctx **ctxs, int nr_ctxs);#ifdef CONFIG_DAMON_VADDR bool damon_va_target_valid (void *t); -void damon_va_set_primitives (struct damon_ctx *ctx); +void damon_va_set_operations (struct damon_ctx *ctx);#endif /* CONFIG_DAMON_VADDR */ #ifdef CONFIG_DAMON_PADDR bool damon_pa_target_valid (void *t); -void damon_pa_set_primitives (struct damon_ctx *ctx); +void damon_pa_set_operations (struct damon_ctx *ctx);#endif /* CONFIG_DAMON_PADDR */ #endif /* _DAMON_H */
mm/damon/Kconfig +6 -6
@@ -25,27 +25,27 @@ config DAMON_KUNIT_TEST If unsure, say N. config DAMON_VADDR - bool "Data access monitoring primitives for virtual address spaces" + bool "Data access monitoring operations for virtual address spaces" depends on DAMON && MMU select PAGE_IDLE_FLAG help - This builds the default data access monitoring primitives for DAMON + This builds the default data access monitoring operations for DAMON that work for virtual address spaces. config DAMON_PADDR - bool "Data access monitoring primitives for the physical address space" + bool "Data access monitoring operations for the physical address space" depends on DAMON && MMU select PAGE_IDLE_FLAG help - This builds the default data access monitoring primitives for DAMON + This builds the default data access monitoring operations for DAMON that works for the physical address space. config DAMON_VADDR_KUNIT_TEST - bool "Test for DAMON primitives" if !KUNIT_ALL_TESTS + bool "Test for DAMON operations" if !KUNIT_ALL_TESTS depends on DAMON_VADDR && KUNIT=y default KUNIT_ALL_TESTS help - This builds the DAMON virtual addresses primitives Kunit test suite. + This builds the DAMON virtual addresses operations Kunit test suite. For more information on KUnit and unit tests in general, please refer to the KUnit documentation.
mm/damon/Makefile +2 -2
@@ -1,7 +1,7 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_DAMON) := core.o -obj-$(CONFIG_DAMON_VADDR) += prmtv-common.o vaddr.o -obj-$(CONFIG_DAMON_PADDR) += prmtv-common.o paddr.o +obj-$(CONFIG_DAMON_VADDR) += ops-common.o vaddr.o +obj-$(CONFIG_DAMON_PADDR) += ops-common.o paddr.o obj-$(CONFIG_DAMON_DBGFS) += dbgfs.o obj-$(CONFIG_DAMON_RECLAIM) += reclaim.o
mm/damon/core.c +33 -32
180 lines not on this page · raw message
mm/damon/dbgfs-test.h +1 -1
@@ -74,7 +74,7 @@ static void damon_dbgfs_test_set_targets(struct kunit *test)char buf[64 ];/* Make DAMON consider target has no pid */ - ctx->primitive = (struct damon_primitive ){}; + ctx->ops = (struct damon_operations ){};dbgfs_set_targets (ctx,0 ,NULL );sprint_target_ids (ctx, buf,64 );
mm/damon/dbgfs.c +5 -5
@@ -56,7 +56,7 @@ static ssize_t dbgfs_attrs_read(struct file *file,mutex_lock (&ctx->kdamond_lock); ret =scnprintf (kbuf,ARRAY_SIZE (kbuf),"%lu %lu %lu %lu %lu\n" , ctx->sample_interval, ctx->aggr_interval, - ctx->primitive_update_interval, ctx->min_nr_regions, + ctx->ops_update_interval, ctx->min_nr_regions, ctx->max_nr_regions);mutex_unlock (&ctx->kdamond_lock);
@@ -277,7 +277,7 @@ static ssize_t dbgfs_schemes_write(struct file *file, const char __user *buf,static inline bool target_has_pid (const struct damon_ctx *ctx) { -return ctx->primitive.target_valid == damon_va_target_valid; +return ctx->ops.target_valid == damon_va_target_valid; }static ssize_t sprint_target_ids (struct damon_ctx *ctx,char *buf,ssize_t len)
@@ -477,9 +477,9 @@ static ssize_t dbgfs_target_ids_write(struct file *file,/* Configure the context for the address space type */ if (id_is_pid) -damon_va_set_primitives (ctx); +damon_va_set_operations (ctx);else -damon_pa_set_primitives (ctx); +damon_pa_set_operations (ctx); ret =dbgfs_set_targets (ctx, nr_targets, target_pids);if (!ret)
@@ -735,7 +735,7 @@ static struct damon_ctx *dbgfs_new_ctx(void)if (!ctx)return NULL ; -damon_va_set_primitives (ctx); +damon_va_set_operations (ctx); ctx->callback.before_terminate = dbgfs_before_terminate;return ctx; }
mm/damon/ops-common.c renamed from mm/damon/prmtv-common.c +1 -1
@@ -10,7 +10,7 @@#include <linux/pagemap.h> #include <linux/rmap.h> -#include "prmtv-common.h" +#include "ops-common.h" /* * Get an online page for a pfn if it's in the LRU list. Otherwise, returns
mm/damon/ops-common.h renamed from mm/damon/prmtv-common.h +0 -0
mm/damon/paddr.c +11 -11
@@ -14,7 +14,7 @@#include <linux/swap.h> #include "../internal.h" -#include "prmtv-common.h" +#include "ops-common.h" static bool __damon_pa_mkold (struct page *page,struct vm_area_struct *vma,unsigned long addr,void *arg)
@@ -261,15 +261,15 @@ static int damon_pa_scheme_score(struct damon_ctx *context,return DAMOS_MAX_SCORE ; } -void damon_pa_set_primitives (struct damon_ctx *ctx) +void damon_pa_set_operations (struct damon_ctx *ctx) { - ctx->primitive.init =NULL ; - ctx->primitive.update =NULL ; - ctx->primitive.prepare_access_checks = damon_pa_prepare_access_checks; - ctx->primitive.check_accesses = damon_pa_check_accesses; - ctx->primitive.reset_aggregated =NULL ; - ctx->primitive.target_valid = damon_pa_target_valid; - ctx->primitive.cleanup =NULL ; - ctx->primitive.apply_scheme = damon_pa_apply_scheme; - ctx->primitive.get_scheme_score = damon_pa_scheme_score; + ctx->ops.init =NULL ; + ctx->ops.update =NULL ; + ctx->ops.prepare_access_checks = damon_pa_prepare_access_checks; + ctx->ops.check_accesses = damon_pa_check_accesses; + ctx->ops.reset_aggregated =NULL ; + ctx->ops.target_valid = damon_pa_target_valid; + ctx->ops.cleanup =NULL ; + ctx->ops.apply_scheme = damon_pa_apply_scheme; + ctx->ops.get_scheme_score = damon_pa_scheme_score; }
mm/damon/reclaim.c +1 -1
@@ -384,7 +384,7 @@ static int __init damon_reclaim_init(void)if (!ctx)return -ENOMEM ; -damon_pa_set_primitives (ctx); +damon_pa_set_operations (ctx); ctx->callback.after_aggregation = damon_reclaim_after_aggregation; target =damon_new_target ();
mm/damon/vaddr-test.h +1 -1
@@ -314,7 +314,7 @@ static struct kunit_case damon_test_cases[] = { };static struct kunit_suite damon_test_suite = { - .name ="damon-primitives" , + .name ="damon-operations" , .test_cases = damon_test_cases, };kunit_test_suite (damon_test_suite);
mm/damon/vaddr.c +11 -11
@@ -15,7 +15,7 @@#include <linux/pagewalk.h> #include <linux/sched/mm.h> -#include "prmtv-common.h" +#include "ops-common.h" #ifdef CONFIG_DAMON_VADDR_KUNIT_TEST #undef DAMON_MIN_REGION
@@ -739,17 +739,17 @@ static int damon_va_scheme_score(struct damon_ctx *context,return DAMOS_MAX_SCORE ; } -void damon_va_set_primitives (struct damon_ctx *ctx) +void damon_va_set_operations (struct damon_ctx *ctx) { - ctx->primitive.init = damon_va_init; - ctx->primitive.update = damon_va_update; - ctx->primitive.prepare_access_checks = damon_va_prepare_access_checks; - ctx->primitive.check_accesses = damon_va_check_accesses; - ctx->primitive.reset_aggregated =NULL ; - ctx->primitive.target_valid = damon_va_target_valid; - ctx->primitive.cleanup =NULL ; - ctx->primitive.apply_scheme = damon_va_apply_scheme; - ctx->primitive.get_scheme_score = damon_va_scheme_score; + ctx->ops.init = damon_va_init; + ctx->ops.update = damon_va_update; + ctx->ops.prepare_access_checks = damon_va_prepare_access_checks; + ctx->ops.check_accesses = damon_va_check_accesses; + ctx->ops.reset_aggregated =NULL ; + ctx->ops.target_valid = damon_va_target_valid; + ctx->ops.cleanup =NULL ; + ctx->ops.apply_scheme = damon_va_apply_scheme; + ctx->ops.get_scheme_score = damon_va_scheme_score; }#include "vaddr-test.h"
Signature · 1 line
2.17.1
SeongJae Park
maintainerPATCH 4/8 mm/damon/reclaim: Use damon_select_ops() instead of damon_{v,p}a_set_operations()
In reply to SeongJae ParkThis commit makes DAMON_RECLAIM to select the registered monitoring operations for the physical address space instead of setting it on its own. This allows DAMON_RECLAIM be independent of DAMON_PADDR, but leave the dependency as is, because it's the only one monitoring operations it use, and therefore it makes no sense to build DAMON_RECLAIM without DAMON_PADDR.
--- mm/damon/reclaim.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
mm/damon/reclaim.c +3 -1
@@ -384,7 +384,9 @@ static int __init damon_reclaim_init(void)if (!ctx)return -ENOMEM ; -damon_pa_set_operations (ctx); +if (damon_select_ops (ctx,DAMON_OPS_PADDR )) +return -EINVAL ; + ctx->callback.after_aggregation = damon_reclaim_after_aggregation; target =damon_new_target ();
Signature · 1 line
2.17.1
SeongJae Park
maintainerPATCH 6/8 mm/damon/dbgfs: Use operations id for knowing if the target has pid
In reply to SeongJae ParkDAMON debugfs interface depends on monitoring operations for virtual address spaces because it knows if the target has pid or not by seeing if the context is configured to use one of the virtual address space monitoring operation functions. We can replace that check with 'enum damon_ops_id' now, to make it independent. This commit makes the change.
--- mm/damon/dbgfs.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
mm/damon/dbgfs.c +3 -3
@@ -277,7 +277,7 @@ static ssize_t dbgfs_schemes_write(struct file *file, const char __user *buf,static inline bool target_has_pid (const struct damon_ctx *ctx) { -return ctx->ops.target_valid == damon_va_target_valid; +return ctx->ops.id ==DAMON_OPS_VADDR ; }static ssize_t sprint_target_ids (struct damon_ctx *ctx,char *buf,ssize_t len)
@@ -741,8 +741,8 @@ static struct damon_ctx *dbgfs_new_ctx(void)if (!ctx)return NULL ; -if (damon_select_ops (ctx,DAMON_OPS_VADDR ) &&damon_select_ops (ctx, -DAMON_OPS_PADDR )) { +if (damon_select_ops (ctx,DAMON_OPS_VADDR ) && +damon_select_ops (ctx,DAMON_OPS_PADDR )) {damon_destroy_ctx (ctx);return NULL ; }
Signature · 1 line
2.17.1
SeongJae Park
maintainerPATCH 5/8 mm/damon/dbgfs: Use damon_select_ops() instead of damon_{v,p}a_set_operations()
In reply to SeongJae ParkThis commit makes DAMON debugfs interface to select the registered monitoring operations for the physical address space or virtual address spaces depending on user requests instead of setting it on its own. Note that DAMON debugfs interface is still dependent to DAMON_VADDR with this change, because it is also using its symbol, 'damon_va_target_valid'.
--- mm/damon/dbgfs.c | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-)
mm/damon/dbgfs.c +13 -3
@@ -474,12 +474,18 @@ static ssize_t dbgfs_target_ids_write(struct file *file,/* remove previously set targets */ dbgfs_set_targets (ctx,0 ,NULL ); +if (!nr_targets) { + ret = count; + goto unlock_out; + }/* Configure the context for the address space type */ if (id_is_pid) -damon_va_set_operations (ctx); + ret =damon_select_ops (ctx,DAMON_OPS_VADDR );else -damon_pa_set_operations (ctx); + ret =damon_select_ops (ctx,DAMON_OPS_PADDR ); +if (ret) + goto unlock_out; ret =dbgfs_set_targets (ctx, nr_targets, target_pids);if (!ret)
@@ -735,7 +741,11 @@ static struct damon_ctx *dbgfs_new_ctx(void)if (!ctx)return NULL ; -damon_va_set_operations (ctx); +if (damon_select_ops (ctx,DAMON_OPS_VADDR ) &&damon_select_ops (ctx, +DAMON_OPS_PADDR )) { +damon_destroy_ctx (ctx); +return NULL ; + } ctx->callback.before_terminate = dbgfs_before_terminate;return ctx; }
Signature · 1 line
2.17.1
SeongJae Park
maintainerPATCH 8/8 mm/damon/paddr,vaddr: Remove damon_{p,v}a_{target_valid,set_operations}()
In reply to SeongJae ParkBecause DAMON debugfs interface and DAMON-based proactive reclaim are now using monitoring operations via registration mechanism, damon_{p,v}a_{target_valid,set_operations}() functions have no user. This commit clean them up.
--- include/linux/damon.h | 10 ---------- mm/damon/paddr.c | 20 +------------------- mm/damon/vaddr.c | 15 +-------------- 3 files changed, 2 insertions(+), 43 deletions(-)
include/linux/damon.h +0 -10
@@ -513,14 +513,4 @@ int damon_stop(struct damon_ctx **ctxs, int nr_ctxs);#endif /* CONFIG_DAMON */ -#ifdef CONFIG_DAMON_VADDR -bool damon_va_target_valid (void *t); -void damon_va_set_operations (struct damon_ctx *ctx); -#endif /* CONFIG_DAMON_VADDR */ - -#ifdef CONFIG_DAMON_PADDR -bool damon_pa_target_valid (void *t); -void damon_pa_set_operations (struct damon_ctx *ctx); -#endif /* CONFIG_DAMON_PADDR */ -#endif /* _DAMON_H */
mm/damon/paddr.c +1 -19
@@ -208,11 +208,6 @@ static unsigned int damon_pa_check_accesses(struct damon_ctx *ctx)return max_nr_accesses; } -bool damon_pa_target_valid (void *t) -{ -return true; -} -static unsigned long damon_pa_apply_scheme (struct damon_ctx *ctx,struct damon_target *t,struct damon_region *r,struct damos *scheme)
@@ -261,19 +256,6 @@ static int damon_pa_scheme_score(struct damon_ctx *context,return DAMOS_MAX_SCORE ; } -void damon_pa_set_operations (struct damon_ctx *ctx) -{ - ctx->ops.init =NULL ; - ctx->ops.update =NULL ; - ctx->ops.prepare_access_checks = damon_pa_prepare_access_checks; - ctx->ops.check_accesses = damon_pa_check_accesses; - ctx->ops.reset_aggregated =NULL ; - ctx->ops.target_valid = damon_pa_target_valid; - ctx->ops.cleanup =NULL ; - ctx->ops.apply_scheme = damon_pa_apply_scheme; - ctx->ops.get_scheme_score = damon_pa_scheme_score; -} -static int __init damon_pa_initcall (void ) {struct damon_operations ops = {
@@ -283,7 +265,7 @@ static int __init damon_pa_initcall(void) .prepare_access_checks = damon_pa_prepare_access_checks, .check_accesses = damon_pa_check_accesses, .reset_aggregated = NULL, - .target_valid = damon_pa_target_valid, + .target_valid = NULL, .cleanup = NULL, .apply_scheme = damon_pa_apply_scheme, .get_scheme_score = damon_pa_scheme_score,
mm/damon/vaddr.c +1 -14
@@ -653,7 +653,7 @@ static unsigned int damon_va_check_accesses(struct damon_ctx *ctx)* Functions for the target validity check and cleanup */ -bool damon_va_target_valid (void *target) +static bool damon_va_target_valid (void *target) {struct damon_target *t = target;struct task_struct *task;
@@ -739,19 +739,6 @@ static int damon_va_scheme_score(struct damon_ctx *context,return DAMOS_MAX_SCORE ; } -void damon_va_set_operations (struct damon_ctx *ctx) -{ - ctx->ops.init = damon_va_init; - ctx->ops.update = damon_va_update; - ctx->ops.prepare_access_checks = damon_va_prepare_access_checks; - ctx->ops.check_accesses = damon_va_check_accesses; - ctx->ops.reset_aggregated =NULL ; - ctx->ops.target_valid = damon_va_target_valid; - ctx->ops.cleanup =NULL ; - ctx->ops.apply_scheme = damon_va_apply_scheme; - ctx->ops.get_scheme_score = damon_va_scheme_score; -} -static int __init damon_va_initcall (void ) {struct damon_operations ops = {
Signature · 1 line
2.17.1
SeongJae Park
maintainerPATCH 7/8 mm/damon/dbgfs-test: Fix is_target_id() change
In reply to SeongJae ParkDAMON kunit tests for DAMON debugfs interface fails because it still assumes setting empty monitoring operations makes DAMON debugfs interface believe the target of the context don't have pid. This commit fixes the kunit test fails by explicitly setting the context's monitoring operations with the operations for the physical address space, which let debugfs knows the target will not have pid.
--- mm/damon/dbgfs-test.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
mm/damon/dbgfs-test.h +3 -1
@@ -74,7 +74,7 @@ static void damon_dbgfs_test_set_targets(struct kunit *test)char buf[64 ];/* Make DAMON consider target has no pid */ - ctx->ops = (struct damon_operations ){}; +damon_select_ops (ctx,DAMON_OPS_PADDR );dbgfs_set_targets (ctx,0 ,NULL );sprint_target_ids (ctx, buf,64 );
@@ -111,6 +111,8 @@ static void damon_dbgfs_test_set_init_regions(struct kunit *test)int i, rc;char buf[256 ]; +damon_select_ops (ctx,DAMON_OPS_PADDR ); +dbgfs_set_targets (ctx,3 ,NULL );/* Put valid inputs and check the results */
Signature · 1 line
2.17.1