github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-31 02:24:24 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

mm/damon: hide kdamond and kdamond_lock of damon_ctx

Browse Source 
There is no DAMON API caller that directly access 'kdamond' and
'kdamond_lock' fields of 'struct damon_ctx'.  Keeping those exposed could
only encourage creative but error-prone usages.  Hide them from DAMON API
callers by marking those as private fields.

Link: https://lkml.kernel.org/r/20260115152047.68415-6-sj@kernel.org
Signed-off-by: SeongJae Park <sj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
This commit is contained in:
SeongJae Park 2026-01-15 07:20:45 -08:00 committed by Andrew Morton
parent 33402229d2
commit 6fe0e6d599
1 changed files with 14 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
include/linux/damon.h
View File

@ -759,23 +759,20 @@ struct damon_attrs {
* of the monitoring.
*
* @attrs: Monitoring attributes for accuracy/overhead control.
* @kdamond: Kernel thread who does the monitoring.
* @kdamond_lock: Mutex for the synchronizations with @kdamond.
*
* For each monitoring context, one kernel thread for the monitoring is
* created. The pointer to the thread is stored in @kdamond.
* For each monitoring context, one kernel thread for the monitoring, namely
* kdamond, is created. The pid of kdamond can be retrieved using
* damon_kdamond_pid().
*
* 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_operations.target_valid of @ops. The
* termination can also be explicitly requested by calling damon_stop().
* The thread sets @kdamond to NULL when it terminates. Therefore, users can
* know whether the monitoring is ongoing or terminated by reading @kdamond.
* Reads and writes to @kdamond from outside of the monitoring thread must
* be protected by @kdamond_lock.
* Once started, kdamond runs until explicitly required to be terminated or
* every monitoring target is invalid. The validity of the targets is checked
* via the &damon_operations.target_valid of @ops. The termination can also be
* explicitly requested by calling damon_stop(). To know if a kdamond is
* running, damon_is_running() can be used.
*
* Note that the monitoring thread protects only @kdamond via @kdamond_lock.
* Accesses to other fields must be protected by themselves.
* While the kdamond is running, all accesses to &struct damon_ctx from a
* thread other than the kdamond should be made using safe DAMON APIs,
* including damon_call() and damos_walk().
*
* @ops: Set of monitoring operations for given use cases.
* @addr_unit: Scale factor for core to ops address conversion.
@ -816,10 +813,12 @@ struct damon_ctx {
struct damos_walk_control *walk_control;
struct mutex walk_control_lock;
/* public: */
/* Working thread of the given DAMON context */
struct task_struct *kdamond;
/* Protects @kdamond field access */
struct mutex kdamond_lock;
/* public: */
struct damon_operations ops;
unsigned long addr_unit;
unsigned long min_sz_region;