mm/damon/core: error damos_commit_quota_goal() for zero target_value
Subsystems (3)
SJ Park
maintainerRFC PATCH 1/1 mm/damon/core: error damos_commit_quota_goal() for zero target_value
Patch series "mm/damon: move zero damos quota target_value handling to the core layer".
Having zero DAMOS quota target value can cause division by zero. DAMON API callers are checking the target value parameters to avoid that. It is easy to make mistakes in some of the multiple API callers. Move that to the core layer.
Patch 1 adds the corner case handling into the core layer DAMON parameters validation logic. Patches 2 and 3 remove no more needed DAMON API callers side handling of the corner case in DAMON_LRU_SORT and DMON_SAMPLIE_MTIER, respectively.
This patch (of 3):
If a DAMOS scheme has a damos_quota_goal of zero target_value, damos_quota_goal() could trigger division-by-zero error. Hence each DAMON API callers should do the zero target_value validation. It is easy to make mistakes. Actually such bugs in DAMON_LRU_SORT and DAMON_SAMPLE_MTIER were found and fixed [1].
It is better to handle the corner case only once in the core layer, instead of multiple places in all DAMON API callers. One straightforward option is using an alternative denominator for the corner case in the damos_quota_goal(). However, the zero target_value is meaningless. In this case, the quota goal is always evaluated as achieved or over-achieved. The quota will only keep being reduced.
Simply avoid using zero target_value by adding a check in the core layer DAMOS quota goal parameters validation/commit path, damos_commit_quota_goal(). Update it to return an error in the case. Also update its caller to propagate the error.
Notes for stable kernel porting. The upstream commit doesn't have
Fixes: and therefore not ported to stable kernels. It turned out it fixes commit 8b549a4fd3c5 ("mm/damon/sysfs-schemes: commit damos quota goals user input to DAMOS") which was merged into v6.8. The user impact is a race condition that can result in divide-by-zero. Hence backport. Reproducing the issue requires sysfs write permission, certain DAMON ABI usages that are supposed to be uncommon, and a rare race timing, though. The issue was discovered [2] by Sashiko as a part [3] of its bug report.
Also, the upstream commit on this stable kernel can fix the issue for parameters commit paths but DAMON start path. That's because DAMON start path does not invoke damon_commit_quota_goals(). To fix the path with minimum change, add a new small validation of quota goal target value before damon_start() call.
[2] https://sashiko.dev/#/bug/linux-7f814c9a-986f-4103-a55a-ef9537dcf62b
[3] https://lore.kernel.org/[email protected]
--- mm/damon/core.c | 18 +++++++++++++----- mm/damon/sysfs.c | 16 ++++++++++++++++ 2 files changed, 29 insertions(+), 5 deletions(-)
mm/damon/core.c +13 -5
@@ -698,14 +698,17 @@ static struct damos_quota_goal *damos_nth_quota_goal(return NULL ; } -static void damos_commit_quota_goal ( +static int damos_commit_quota_goal (struct damos_quota_goal *dst,struct damos_quota_goal *src) { +if (!src->target_value) +return -EINVAL ; dst->metric = src->metric; dst->target_value = src->target_value;if (dst->metric ==DAMOS_QUOTA_USER_INPUT ) dst->current_value = src->current_value;/* keep last_psi_total as is, since it will be updated in next cycle */ +return 0 ; }/**
@@ -723,18 +726,23 @@ static void damos_commit_quota_goal(int damos_commit_quota_goals (struct damos_quota *dst,struct damos_quota *src) {struct damos_quota_goal *dst_goal, *next, *src_goal, *new_goal; -int i =0 , j =0 ; +int i =0 , j =0 , err;damos_for_each_quota_goal_safe (dst_goal, next, dst) { src_goal =damos_nth_quota_goal (i++, src); -if (src_goal) -damos_commit_quota_goal (dst_goal, src_goal); -else +if (src_goal) { + err =damos_commit_quota_goal (dst_goal, src_goal); +if (err) +return err; + }else {damos_destroy_quota_goal (dst_goal); + } }damos_for_each_quota_goal_safe (src_goal, next, src) {if (j++ < i)continue ; +if (!src_goal->target_value) +return -EINVAL ; new_goal =damos_new_quota_goal ( src_goal->metric, src_goal->target_value);if (!new_goal)
mm/damon/sysfs.c +16 -0
@@ -1497,6 +1497,20 @@ static struct damon_ctx *damon_sysfs_build_ctx(return ctx; } +static bool damon_sysfs_valid_start_ctx (struct damon_ctx *ctx) +{ +struct damos *s; +struct damos_quota_goal *g; + +damon_for_each_scheme (s, ctx) { +damos_for_each_quota_goal (g, &s->quota) { +if (!g->targe_value) +return false; + } + } +return true; +} +static int damon_sysfs_turn_damon_on (struct damon_sysfs_kdamond *kdamond) {struct damon_ctx *ctx;
@@ -1517,6 +1531,8 @@ static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond) ctx =damon_sysfs_build_ctx (kdamond->contexts->contexts_arr[0 ]);if (IS_ERR (ctx))return PTR_ERR (ctx); +if (!damon_sysfs_valid_start_ctx (ctx)) +return -EINVAL ; err =damon_start (&ctx,1 , false);if (err) {damon_destroy_ctx (ctx);
base-commit: 85d82e0d7c2dfd3e75d34f35b7ebbf41f45c9c4e
Signature · 1 line
2.47.3
[email protected]
AI reviewThank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider: - [Medium] mm/damon/sysfs: ctx memory leak in damon_sysfs_turn_damon_on() - [Low] mm/damon/sysfs: unknown…
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium] mm/damon/sysfs: ctx memory leak in damon_sysfs_turn_damon_on()
- [Low] mm/damon/sysfs: unknown member targe_value in damon_sysfs_valid_start_ctx() --
commit 1635d9f393d64d22688141e9540fde6f98f5d6bb
Author: SJ Park <[email protected]>
mm/damon/core: error damos_commit_quota_goal() for zero target_value
This patch rejects zero target_value in DAMOS quota goals during parameter commit in damos_commit_quota_goal() and damos_commit_quota_goals() to avoid division-by-zero errors. For this stable backport, it also adds a validation helper before damon_start() in damon_sysfs_turn_damon_on().
Quoted 11 lines
mm/damon/sysfs.c +3
-0@@ -1497,6 +1497,20 @@ static struct damon_ctx *damon_sysfs_build_ctx(return ctx; } +static bool damon_sysfs_valid_start_ctx (struct damon_ctx *ctx) +{ +struct damos *s;
mm/damon/sysfs.c static struct damon_ctx *damon_sysfs_build_ctx( · line 1512
Quoted 10 lines
mm/damon/sysfs.c +10
-0+struct damos_quota_goal *g; + +damon_for_each_scheme (s, ctx) { +damos_for_each_quota_goal (g, &s->quota) { +if (!g->targe_value) +return false; + } + } +return true; +}
[Severity: Low]
Will mm/damon/sysfs.c fail to build in damon_sysfs_valid_start_ctx() due to referencing g->targe_value instead of g->target_value?
In include/linux/damon.h, struct damos_quota_goal defines this field as:
struct damos_quota_goal {
enum damos_quota_goal_metric metric;
unsigned long target_value;
unsigned long current_value;mm/damon/sysfs.c static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond) · line 1535
Quoted 10 lines
mm/damon/sysfs.c +3
-0+static int damon_sysfs_turn_damon_on (struct damon_sysfs_kdamond *kdamond) {struct damon_ctx *ctx;@@ -1517,6 +1531,8 @@ static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond) ctx =damon_sysfs_build_ctx (kdamond->contexts->contexts_arr[0 ]);if (IS_ERR (ctx))return PTR_ERR (ctx); +if (!damon_sysfs_valid_start_ctx (ctx)) +return -EINVAL ;
[Severity: Medium]
Does damon_sysfs_turn_damon_on() leak ctx and its associated allocations when damon_sysfs_valid_start_ctx(ctx) returns false?
When userspace writes "on" to the kdamond state sysfs file with a scheme quota goal whose target_value is zero, damon_sysfs_build_ctx() allocates ctx along with its targets, regions, schemes, quota goals, filters, and any target struct pid references. Returning -EINVAL directly here skips damon_destroy_ctx(ctx) (and target pid cleanup via damon_sysfs_destroy_targets(ctx)), whereas the damon_start() error path right below destroys ctx before returning:
err = damon_start(&ctx, 1, false);
if (err) {
damon_destroy_ctx(ctx);
return err;
}Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
SJ Park
maintainerQuoted 36 lines · On Sun, 25 Oct 2026 18:33:53 +0000 [email protected] wrote:
Thank you for your contribution! Sashiko AI review found 2 potential issue(s) to consider:
- [Medium]mm/damon/sysfs: ctx memory leak indamon_sysfs_turn_damon_on()
- [Low]mm/damon/sysfs: unknown membertarge_valueindamon_sysfs_valid_start_ctx()--commit
1635d9f393d64d22688141e9540fde6f98f5d6bb
Author: SJ Park <[email protected]>
mm/damon/core: errordamos_commit_quota_goal()for zerotarget_valueThis patch rejects zero
target_valuein DAMOS quota goals during parameter commit indamos_commit_quota_goal()anddamos_commit_quota_goals()to avoid division-by-zero errors. For this stable backport, it also adds a validation helper beforedamon_start()indamon_sysfs_turn_damon_on().Quoted 17 lines
mm/damon/sysfs.c +9
-0@@ -1497,6 +1497,20 @@ static struct damon_ctx *damon_sysfs_build_ctx(return ctx; } +static bool damon_sysfs_valid_start_ctx (struct damon_ctx *ctx) +{ +struct damos *s; +struct damos_quota_goal *g; + +damon_for_each_scheme (s, ctx) { +damos_for_each_quota_goal (g, &s->quota) { +if (!g->targe_value) +return false;
Quoted 8 lines
mm/damon/sysfs.c static struct damon_ctx *damon_sysfs_build_ctx( · line 1512
Quoted 4 lines
mm/damon/sysfs.c +4
-0+ } + } +return true; +}[Severity: Low]
Willmm/damon/sysfs.cfail to build indamon_sysfs_valid_start_ctx()due to referencingg->targe_valueinstead ofg->target_value?
Nice catch. My build test was somehow configured to disable DAMON_SYSFS. I will fix this in the next spin.
Also, my build test found an issue in macro expansion after fixing the config. I will add below change for the two build issues.
'''
@@ -1503,8 +1503,8 @@ static bool damon_sysfs_valid_start_ctx(struct damon_ctx *ctx)
struct damos_quota_goal *g;
damon_for_each_scheme(s, ctx) {- damos_for_each_quota_goal(g, &s->quota) {
- if (!g->targe_value)
+ damos_for_each_quota_goal(g, (&s->quota)) {
+ if (!g->target_value)
return false;
}
}'''
Quoted 8 lines
In
include/linux/damon.h, structdamos_quota_goaldefines this field as:struct damos_quota_goal { enum damos_quota_goal_metric metric; unsigned long target_value; unsigned long current_value;
Quoted 14 lines
mm/damon/sysfs.c static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond) · line 1535
Quoted 10 lines
mm/damon/sysfs.c +3
-0+static int damon_sysfs_turn_damon_on (struct damon_sysfs_kdamond *kdamond) {struct damon_ctx *ctx;@@ -1517,6 +1531,8 @@ static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond) ctx =damon_sysfs_build_ctx (kdamond->contexts->contexts_arr[0 ]);if (IS_ERR (ctx))return PTR_ERR (ctx); +if (!damon_sysfs_valid_start_ctx (ctx)) +return -EINVAL ;[Severity: Medium]
Doesdamon_sysfs_turn_damon_on()leak ctx and its associated allocations whendamon_sysfs_valid_start_ctx(ctx)returns false?
Good catch. I will destroy the ctx in the error case in the next version, like below:
'''
@@ -1531,8 +1531,10 @@ static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond)
ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]);
if (IS_ERR(ctx))
return PTR_ERR(ctx);
- if (!damon_sysfs_valid_start_ctx(ctx))
+ if (!damon_sysfs_valid_start_ctx(ctx)) {
+ damon_destroy_ctx(ctx);
return -EINVAL;
+ }
err = damon_start(&ctx, 1, false);
if (err) {
damon_destroy_ctx(ctx);'''
Quoted 9 lines
When userspace writes "on" to the kdamond state sysfs file with a scheme quota goal whose
target_valueis zero,damon_sysfs_build_ctx()allocates ctx along with its targets, regions, schemes, quota goals, filters, and any target struct pid references. Returning-EINVALdirectly here skipsdamon_destroy_ctx(ctx)(and target pid cleanup viadamon_sysfs_destroy_targets(ctx)), whereas thedamon_start()error path right below destroys ctx before returning:
Quoted 8 lines
err = damon_start(&ctx, 1, false); if (err) { damon_destroy_ctx(ctx); return err; }Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Thanks,
SJ