mm/damon: let DAMON be paused and resumed

DAMON supports only start and stop of the execution. When it is stopped, its internal data that it self-trained goes away. It will be useful if the execution can be paused and resumed with the previous self-trained data.

Introduce per-context API parameter, 'paused', for the purpose. The parameter can be set and unset while DAMON is running and paused, using the online parameters commit helper functions (damon_commit_ctx() and damon_call()). Once 'paused' is set, the kdamond_fn() main loop does only limited works with sampling interval sleep during the works. The limited works include the handling of the online parameters update, so that users can unset the 'pause' and resume the execution when they want. It also keep checking DAMON stop conditions and handling of it, so that DAMON can be stopped while paused if needed.

Signed-off-by SeongJae Park <[email protected]>

---
 include/linux/damon.h | 2 ++
 mm/damon/core.c       | 9 +++++++++
 2 files changed, 11 insertions(+)

include/linux/damon.h +0 -0

index 3a441fbca170d..421e51eff3bd2 100644

DAMON supports only start and stop of the execution. When it is stopped, its internal data that it self-trained goes away. It will be useful if the execution can be paused and resumed with the previous self-trained data.

Introduce per-context API parameter, 'paused', for the purpose. The parameter can be set and unset while DAMON is running and paused, using the online parameters commit helper functions (damon_commit_ctx() and damon_call()). Once 'paused' is set, the kdamond_fn() main loop does only limited works with sampling interval sleep during the works. The limited works include the handling of the online parameters update, so that users can unset the 'pause' and resume the execution when they want. It also keep checking DAMON stop conditions and handling of it, so that DAMON can be stopped while paused if needed.

Signed-off-by SeongJae Park <[email protected]>

---
 include/linux/damon.h | 2 ++
 mm/damon/core.c       | 9 +++++++++
 2 files changed, 11 insertions(+)

include/linux/damon.h +2 -0

index 3a441fbca170d..421e51eff3bd2 100644
@@ -811,6 +811,8 @@ struct damon_ctx {
 	 * intervals tuning
 	 */
 	unsigned long next_intervals_tune_sis;
+	/* pause kdamond main loop */
+	bool pause;
 	/* for waiting until the execution of the kdamond_fn is started */
 	struct completion kdamond_started;
 	/* for scheme quotas prioritization */

mm/damon/core.c +1 -0

index 339325e1096bc..0b6cb63d64d0e 100644
@@ -1331,6 +1331,7 @@ int damon_commit_ctx(struct damon_ctx *dst, struct damon_ctx *src)
 		if (err)
 			return err;
 	}
+	dst->pause = src->pause;
 	dst->ops = src->ops;
 	dst->addr_unit = src->addr_unit;
 	dst->min_region_sz = src->min_region_sz;

Update DAMON design document for the context execution pause/resume feature.

Signed-off-by SeongJae Park <[email protected]>

---
 Documentation/mm/damon/design.rst | 7 +++++++
 1 file changed, 7 insertions(+)

Documentation/mm/damon/design.rst +0 -0

index 838b14d225193..e2e4fe3fb3986 100644

DAMON test-purpose sysfs interface control Python module, _damon_sysfs, is not supporting the newly added pause file. Add the support of the file, for future test and use of the feature.

Signed-off-by SeongJae Park <[email protected]>

---
 tools/testing/selftests/damon/_damon_sysfs.py | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

tools/testing/selftests/damon/_damon_sysfs.py +0 -0

index 2b4df655d9fd0..120b96ecbd741 100644

The sysfs.py test commits DAMON parameters, dump the internal DAMON state, and show if the parameters are committed as expected using the dumped state. While the dumping is ongoing, DAMON is alive. It can make internal changes including addition and removal of regions. It can therefore make a race that can result in false test results. Pause DAMON execution during the state dumping to avoid such races.

Signed-off-by SeongJae Park <[email protected]>

---
 tools/testing/selftests/damon/sysfs.py | 31 ++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

tools/testing/selftests/damon/sysfs.py +13 -0

index e6d34ba05893f..704729c7a318e 100755
@@ -193,18 +193,48 @@ def assert_ctx_committed(ctx, dump):
     assert_true(dump['pause'] == ctx.pause, 'pause', dump)
 
 def assert_ctxs_committed(kdamonds):
+    ctxs_paused_for_dump = []
+    for kd in kdamonds.kdamonds:
+        for ctx in kd.contexts:
+            if ctx.pause is False:
+                ctx.pause = True
+                err = kd.commit()
+                if err is not None:
+                    print('pause fail (%s)' % err)
+                    kdamonds.stop()
+                    exit(1)
+                ctxs_paused_for_dump.append(ctx)
+
     status, err = dump_damon_status_dict(kdamonds.kdamonds[0].pid)
     if err is not None:
         print(err)
         kdamonds.stop()
         exit(1)
 
+    for kd in kdamonds.kdamonds:

Adding Sashiko comment
(https://lore.kernel.org/https://sashiko.dev/#/patchset/[email protected])
with ': ' line prefix, and my replies in line.

Quoted 39 lines · On Wed, 18 Mar 2026 22:21:53 -0700 SeongJae Park <[email protected]> wrote:

The sysfs.py test commits DAMON parameters, dump the internal DAMON state, and show if the parameters are committed as expected using the dumped state. While the dumping is ongoing, DAMON is alive. It can make internal changes including addition and removal of regions. It can therefore make a race that can result in false test results. Pause DAMON execution during the state dumping to avoid such races.

Signed-off-by SeongJae Park <[email protected]>

---
 tools/testing/selftests/damon/sysfs.py | 31 ++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

tools/testing/selftests/damon/sysfs.py +13 -0

index e6d34ba05893f..704729c7a318e 100755
@@ -193,18 +193,48 @@ def assert_ctx_committed(ctx, dump):
     assert_true(dump['pause'] == ctx.pause, 'pause', dump)
 
 def assert_ctxs_committed(kdamonds):
+    ctxs_paused_for_dump = []
+    for kd in kdamonds.kdamonds:
+        for ctx in kd.contexts:
+            if ctx.pause is False:
+                ctx.pause = True
+                err = kd.commit()
+                if err is not None:
+                    print('pause fail (%s)' % err)
+                    kdamonds.stop()
+                    exit(1)
+                ctxs_paused_for_dump.append(ctx)
+
     status, err = dump_damon_status_dict(kdamonds.kdamonds[0].pid)
     if err is not None:
         print(err)
         kdamonds.stop()
         exit(1)
 
+    for kd in kdamonds.kdamonds:

tools/testing/selftests/damon/sysfs.py def assert_ctx_committed(ctx, dump): · line 224

Quoted 10 lines

tools/testing/selftests/damon/sysfs.py +10 -0

+        for ctx in kd.contexts:
+            if ctx in ctxs_paused_for_dump:
+                ctx.pause = False
+                err = kd.commit()
+                if err is not None:
+                    print('resume fail (%s)' % err)
+                    kdamonds.stop()
+                    exit(1)
+                # restore for comparison
+                ctx.pause = True

: If a kdamond contains multiple contexts, does this loop leave earlier contexts : paused in the kernel?
:
: Since kd.commit() stages and commits the state of all contexts associated with : the kdamond, when kd.commit() is called for the second context, the first : context's local pause attribute is already back to True.
:
: This would cause kd.commit() to write to sysfs and instruct the kernel to : pause the first context again. By the end of this loop, only the last context : in the kdamond would remain unpaused in the kernel.

No. The pause field of the earlier context is set to False, so later kd.commit() will commit the False 'pause' again. But this finds a good point. There is no reason to call kd.commit() for each context. It is more efficient to be called for each kdamond., thouth currently we support only one context per kdamond. I will update the code so, in the next spin.

Quoted 67 lines · On Fri, 20 Mar 2026 08:29:39 -0700 SeongJae Park <[email protected]> wrote:

Adding Sashiko comment
(https://lore.kernel.org/https://sashiko.dev/#/patchset/[email protected])
with ': ' line prefix, and my replies in line.

Quoted 39 lines · On Wed, 18 Mar 2026 22:21:53 -0700 SeongJae Park <[email protected]> wrote:

The sysfs.py test commits DAMON parameters, dump the internal DAMON state, and show if the parameters are committed as expected using the dumped state. While the dumping is ongoing, DAMON is alive. It can make internal changes including addition and removal of regions. It can therefore make a race that can result in false test results. Pause DAMON execution during the state dumping to avoid such races.

Signed-off-by SeongJae Park <[email protected]>

---
 tools/testing/selftests/damon/sysfs.py | 31 ++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

tools/testing/selftests/damon/sysfs.py +13 -0

index e6d34ba05893f..704729c7a318e 100755
@@ -193,18 +193,48 @@ def assert_ctx_committed(ctx, dump):
     assert_true(dump['pause'] == ctx.pause, 'pause', dump)
 
 def assert_ctxs_committed(kdamonds):
+    ctxs_paused_for_dump = []
+    for kd in kdamonds.kdamonds:
+        for ctx in kd.contexts:
+            if ctx.pause is False:
+                ctx.pause = True
+                err = kd.commit()
+                if err is not None:
+                    print('pause fail (%s)' % err)
+                    kdamonds.stop()
+                    exit(1)
+                ctxs_paused_for_dump.append(ctx)
+
     status, err = dump_damon_status_dict(kdamonds.kdamonds[0].pid)
     if err is not None:
         print(err)
         kdamonds.stop()
         exit(1)
 
+    for kd in kdamonds.kdamonds:

tools/testing/selftests/damon/sysfs.py def assert_ctx_committed(ctx, dump): · line 224

Quoted 10 lines

tools/testing/selftests/damon/sysfs.py +10 -0

+        for ctx in kd.contexts:
+            if ctx in ctxs_paused_for_dump:
+                ctx.pause = False
+                err = kd.commit()
+                if err is not None:
+                    print('resume fail (%s)' % err)
+                    kdamonds.stop()
+                    exit(1)
+                # restore for comparison
+                ctx.pause = True

: If a kdamond contains multiple contexts, does this loop leave earlier contexts : paused in the kernel?
:
: Since kd.commit() stages and commits the state of all contexts associated with : the kdamond, when kd.commit() is called for the second context, the first : context's local pause attribute is already back to True.
:
: This would cause kd.commit() to write to sysfs and instruct the kernel to : pause the first context again. By the end of this loop, only the last context : in the kdamond would remain unpaused in the kernel.

Quoted 5 lines

No. The pause field of the earlier context is set to False, so later kd.commit() will commit the False 'pause' again. But this finds a good point. There is no reason to call kd.commit() for each context. It is more efficient to be called for each kdamond., thouth currently we support only one context per kdamond. I will update the code so, in the next spin.

I'm wrong, Sashiko is correct. I missed the last 'ctx.pause = True' in the loop. I will fix this together, like below:

'''

tools/testing/selftests/damon/sysfs.py +18 -15

@@ -201,16 +201,17 @@ def assert_ctx_committed(ctx, dump):
 
 def assert_ctxs_committed(kdamonds):
     ctxs_paused_for_dump = []
+    # pause for safe state dumping
     for kd in kdamonds.kdamonds:
         for ctx in kd.contexts:
             if ctx.pause is False:
                 ctx.pause = True
-                err = kd.commit()
-                if err is not None:
-                    print('pause fail (%s)' % err)
-                    kdamonds.stop()
-                    exit(1)
                 ctxs_paused_for_dump.append(ctx)
+        err = kd.commit()
+        if err is not None:
+            print('pause fail (%s)' % err)
+            kdamonds.stop()
+            exit(1)
 
     status, err = dump_damon_status_dict(kdamonds.kdamonds[0].pid)
     if err is not None:

@@ -218,17 +219,19 @@ def assert_ctxs_committed(kdamonds):
         kdamonds.stop()
         exit(1)
 
+    # resume contexts paused for safe state dumping
     for kd in kdamonds.kdamonds:
-        for ctx in kd.contexts:
-            if ctx in ctxs_paused_for_dump:
-                ctx.pause = False
-                err = kd.commit()
-                if err is not None:
-                    print('resume fail (%s)' % err)
-                    kdamonds.stop()
-                    exit(1)
-                # restore for comparison
-                ctx.pause = True
+        for ctx in ctxs_paused_for_dump:
+            ctx.pause = False
+        err = kd.commit()
+        if err is not None:
+            print('resume fail (%s)' % err)
+            kdamonds.stop()
+            exit(1)
+
+    # restore for comparison
+    for ctx in ctxs_paused_for_dump:
+        ctx.pause = True
 
     ctxs = kdamonds.kdamonds[0].contexts
     dump = status['contexts']

'''