FAILED: patch "[PATCH] mm/damon/core: make charge_addr_from aware of end-address" failed to apply to 6.1-stable tree

mm/damon/core.c static void damon_do_apply_schemes(struct damon_ctx *c, · line 809

[Severity: High]
This is a pre-existing issue, but does the safe iterator in kdamond_apply_schemes() skip newly inserted regions?

mm/damon/core.c:kdamond_apply_schemes() {
    ...
    damon_for_each_region_safe(r, next_r, t) {
        ...
        damon_do_apply_schemes(c, t, r);
    }
}

If damon_do_apply_schemes() calls damon_split_region_at(), it inserts a new region immediately after r. Because next_r is cached before the loop body, the newly inserted right-hand region falls into a blind spot and appears to be skipped for the current aggregation interval.

[Severity: High]
This is a pre-existing issue, but is it possible that reassigning the local region pointer causes subsequent schemes to miss the first half of a split region?

mm/damon/core.c:damon_do_apply_schemes() {
    ...
    damon_for_each_scheme(s, c) {
        ...
        if (quota->charge_addr_from && r->ar.start < quota->charge_addr_from) {
            ...
            damon_split_region_at(t, r, sz);
            r = damon_next_region(r);
            sz = damon_sz_region(r);
        }
        ...
    }
}

Modifying the loop parameter r leaks to subsequent schemes in the iteration, causing them to evaluate only the second half of the split region and completely miss the first half.

[Severity: Medium]
This is a pre-existing issue, but could this logic unconditionally skip the uncharged remainder of a target's last region?

mm/damon/core.c:damon_do_apply_schemes() {
    ...
    if (r == damon_last_region(t)) {
        quota->charge_target_from = NULL;
        quota->charge_addr_from = 0;
        continue;
    }
    ...
}

When resuming from a previous charge window that exhausted its quota in the middle of the last region of a target, it looks like this clears the charge tracking and immediately executes continue, skipping the evaluation of the rest of the region.

[Severity: High]
This is a pre-existing issue, but can this jump break the round-robin mechanism and waste CPU when the remaining quota is less than DAMON_MIN_REGION?

mm/damon/core.c:damon_do_apply_schemes() {
    ...
    if (quota->esz && quota->charged_sz + sz > quota->esz) {
        sz = ALIGN_DOWN(quota->esz - quota->charged_sz, DAMON_MIN_REGION);
        if (!sz)
            goto update_stat;
        damon_split_region_at(t, r, sz);
    }
    ...
}

When the remaining quota is less than DAMON_MIN_REGION, ALIGN_DOWN results in sz == 0. The code then jumps to update_stat, bypassing the charged_sz update. This prevents charged_sz from reaching esz, creating a pseudo-infinite evaluation loop for the rest of the regions without saving the resume state.

Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1