/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Data Access Monitor Unit Tests
 */

#ifdef CONFIG_DAMON_KUNIT_TEST

#ifndef _DAMON_CORE_TEST_H
#define _DAMON_CORE_TEST_H

#include <kunit/test.h>

static void damon_test_regions(struct kunit *test)
{
	struct damon_region *r;
	struct damon_target *t;

	r = damon_new_region(1, 2);
	if (!r)
		kunit_skip(test, "region alloc fail");
	KUNIT_EXPECT_EQ(test, 1ul, r->ar.start);
	KUNIT_EXPECT_EQ(test, 2ul, r->ar.end);
	KUNIT_EXPECT_EQ(test, 0u, r->nr_accesses);

	t = damon_new_target();
	if (!t) {
		damon_free_region(r);
		kunit_skip(test, "target alloc fail");
	}
	KUNIT_EXPECT_EQ(test, 0u, damon_nr_regions(t));

	damon_add_region(r, t);
	KUNIT_EXPECT_EQ(test, 1u, damon_nr_regions(t));

	damon_destroy_region(r, t);
	KUNIT_EXPECT_EQ(test, 0u, damon_nr_regions(t));

	damon_free_target(t);
}

static unsigned int nr_damon_targets(struct damon_ctx *ctx)
{
	struct damon_target *t;
	unsigned int nr_targets = 0;

	damon_for_each_target(t, ctx)
		nr_targets++;

	return nr_targets;
}

static void damon_test_target(struct kunit *test)
{
	struct damon_ctx *c = damon_new_ctx();
	struct damon_target *t;

	if (!c)
		kunit_skip(test, "ctx alloc fail");

	t = damon_new_target();
	if (!t) {
		damon_destroy_ctx(c);
		kunit_skip(test, "target alloc fail");
	}
	KUNIT_EXPECT_EQ(test, 0u, nr_damon_targets(c));

	damon_add_target(c, t);
	KUNIT_EXPECT_EQ(test, 1u, nr_damon_targets(c));

	damon_destroy_target(t, c);
	KUNIT_EXPECT_EQ(test, 0u, nr_damon_targets(c));

	damon_destroy_ctx(c);
}

/*
 * Test kdamond_reset_aggregated()
 *
 * DAMON checks access to each region and aggregates this information as the
 * access frequency of each region.  In detail, it increases '->nr_accesses' of
 * regions that an access has confirmed.  'kdamond_reset_aggregated()' flushes
 * the aggregated information ('->nr_accesses' of each regions) to the result
 * buffer.  As a result of the flushing, the '->nr_accesses' of regions are
 * initialized to zero.
 */
static void damon_test_aggregate(struct kunit *test)
{
	struct damon_ctx *ctx = damon_new_ctx();
	unsigned long saddr[][3] = {{10, 20, 30}, {5, 42, 49}, {13, 33, 55} };
	unsigned long eaddr[][3] = {{15, 27, 40}, {31, 45, 55}, {23, 44, 66} };
	unsigned long accesses[][3] = {{42, 95, 84}, {10, 20, 30}, {0, 1, 2} };
	struct damon_target *t;
	struct damon_region *r;
	int it, ir;

	if (!ctx)
		kunit_skip(test, "ctx alloc fail");

	for (it = 0; it < 3; it++) {
		t = damon_new_target();
		if (!t) {
			damon_destroy_ctx(ctx);
			kunit_skip(test, "target alloc fail");
		}
		damon_add_target(ctx, t);
	}

	it = 0;
	damon_for_each_target(t, ctx) {
		for (ir = 0; ir < 3; ir++) {
			r = damon_new_region(saddr[it][ir], eaddr[it][ir]);
			if (!r) {
				damon_destroy_ctx(ctx);
				kunit_skip(test, "region alloc fail");
			}
			r->nr_accesses = accesses[it][ir];
			damon_add_region(r, t);
		}
		it++;
	}
	kdamond_reset_aggregated(ctx);
	it = 0;
	damon_for_each_target(t, ctx) {
		ir = 0;
		/* '->nr_accesses' should be zeroed */
		damon_for_each_region(r, t) {
			KUNIT_EXPECT_EQ(test, 0u, r->nr_accesses);
			ir++;
		}
		/* regions should be preserved */
		KUNIT_EXPECT_EQ(test, 3, ir);
		it++;
	}
	/* targets also should be preserved */
	KUNIT_EXPECT_EQ(test, 3, it);

	damon_destroy_ctx(ctx);
}

static void damon_test_split_at(struct kunit *test)
{
	struct damon_target *t;
	struct damon_region *r, *r_new;

	t = damon_new_target();
	if (!t)
		kunit_skip(test, "target alloc fail");
	r = damon_new_region(0, 100);
	if (!r) {
		damon_free_target(t);
		kunit_skip(test, "region alloc fail");
	}
	r->nr_accesses = 42;
	r->last_nr_accesses = 15;
	r->probe_hits[0] = 7;
	r->last_probe_hits[0] = 3;
	r->age = 10;
	damon_add_region(r, t);
	damon_split_region_at(t, r, 25);
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 2);
	if (damon_nr_regions(t) != 2)
		goto out;

	KUNIT_EXPECT_EQ(test, r->ar.start, 0ul);
	KUNIT_EXPECT_EQ(test, r->ar.end, 25ul);

	r_new = damon_next_region(r);
	KUNIT_EXPECT_EQ(test, r_new->ar.start, 25ul);
	KUNIT_EXPECT_EQ(test, r_new->ar.end, 100ul);

	KUNIT_EXPECT_EQ(test, r->nr_accesses, r_new->nr_accesses);
	KUNIT_EXPECT_EQ(test, r->last_nr_accesses, r_new->last_nr_accesses);
	KUNIT_EXPECT_EQ(test, r->probe_hits[0], r_new->probe_hits[0]);
	KUNIT_EXPECT_EQ(test, r->last_probe_hits[0], r_new->last_probe_hits[0]);
	KUNIT_EXPECT_EQ(test, r->age, r_new->age);

out:
	damon_free_target(t);
}

static void damon_test_merge_two(struct kunit *test)
{
	struct damon_target *t;
	struct damon_region *r, *r2, *r3;
	int i;

	t = damon_new_target();
	if (!t)
		kunit_skip(test, "target alloc fail");
	r = damon_new_region(0, 100);
	if (!r) {
		damon_free_target(t);
		kunit_skip(test, "region alloc fail");
	}
	r->nr_accesses = 10;
	r->probe_hits[0] = 6;
	r->age = 9;
	damon_add_region(r, t);
	r2 = damon_new_region(100, 300);
	if (!r2) {
		damon_free_target(t);
		kunit_skip(test, "second region alloc fail");
	}
	r2->nr_accesses = 20;
	r2->probe_hits[0] = 14;
	r2->age = 21;
	damon_add_region(r2, t);

	damon_merge_two_regions(t, r, r2);
	KUNIT_EXPECT_EQ(test, r->ar.start, 0ul);
	KUNIT_EXPECT_EQ(test, r->ar.end, 300ul);
	KUNIT_EXPECT_EQ(test, r->nr_accesses, 16u);
	KUNIT_EXPECT_EQ(test, r->probe_hits[0], 11);
	KUNIT_EXPECT_EQ(test, r->age, 17u);

	i = 0;
	damon_for_each_region(r3, t) {
		KUNIT_EXPECT_PTR_EQ(test, r, r3);
		i++;
	}
	KUNIT_EXPECT_EQ(test, i, 1);

	damon_free_target(t);
}

static struct damon_region *__nth_region_of(struct damon_target *t, int idx)
{
	struct damon_region *r;
	unsigned int i = 0;

	damon_for_each_region(r, t) {
		if (i++ == idx)
			return r;
	}

	return NULL;
}

static void damon_test_merge_regions_of(struct kunit *test)
{
	struct damon_ctx *ctx;
	struct damon_target *t;
	struct damon_region *r;
	unsigned long sa[] = {0, 100, 114, 122, 130, 156, 170, 184, 230};
	unsigned long ea[] = {100, 112, 122, 130, 156, 170, 184, 230, 10170};
	unsigned int nrs[] = {0, 0, 10, 10, 20, 30, 1, 2, 5};

	unsigned long saddrs[] = {0, 114, 130, 156, 170, 230};
	unsigned long eaddrs[] = {112, 130, 156, 170, 230, 10170};
	int i;

	ctx = damon_new_ctx();
	if (!ctx)
		kunit_skip(test, "ctx alloc fail");

	t = damon_new_target();
	if (!t) {
		damon_destroy_ctx(ctx);
		kunit_skip(test, "target alloc fail");
	}
	for (i = 0; i < ARRAY_SIZE(sa); i++) {
		r = damon_new_region(sa[i], ea[i]);
		if (!r) {
			damon_free_target(t);
			damon_destroy_ctx(ctx);
			kunit_skip(test, "region alloc fail");
		}
		r->nr_accesses = nrs[i];
		damon_add_region(r, t);
	}

	damon_merge_regions_of(t, 9, 9999, ctx, true);
	/* 0-112, 114-130, 130-156, 156-170, 170-230, 230-10170 */
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 6u);
	if (damon_nr_regions(t) != 6)
		goto out;
	for (i = 0; i < 6; i++) {
		r = __nth_region_of(t, i);
		KUNIT_EXPECT_EQ(test, r->ar.start, saddrs[i]);
		KUNIT_EXPECT_EQ(test, r->ar.end, eaddrs[i]);
	}
out:
	damon_free_target(t);
	damon_destroy_ctx(ctx);
}

static void damon_test_split_regions_of(struct kunit *test)
{
	struct damon_ctx *c;
	struct damon_target *t;
	struct damon_region *r;
	unsigned long sa[] = {0, 300, 500};
	unsigned long ea[] = {220, 400, 700};
	int i;

	c = damon_new_ctx();
	if (!c)
		kunit_skip(test, "ctx alloc fail");

	t = damon_new_target();
	if (!t) {
		damon_destroy_ctx(c);
		kunit_skip(test, "target alloc fail");
	}
	r = damon_new_region(0, 22);
	if (!r) {
		damon_free_target(t);
		damon_destroy_ctx(c);
		kunit_skip(test, "region alloc fail");
	}
	damon_add_region(r, t);
	damon_split_regions_of(c, t, 2, 1);
	KUNIT_EXPECT_LE(test, damon_nr_regions(t), 2u);
	damon_free_target(t);

	t = damon_new_target();
	if (!t) {
		damon_destroy_ctx(c);
		kunit_skip(test, "second target alloc fail");
	}
	r = damon_new_region(0, 220);
	if (!r) {
		damon_free_target(t);
		damon_destroy_ctx(c);
		kunit_skip(test, "second region alloc fail");
	}
	damon_add_region(r, t);
	damon_split_regions_of(c, t, 4, 1);
	KUNIT_EXPECT_LE(test, damon_nr_regions(t), 4u);
	damon_free_target(t);

	t = damon_new_target();
	if (!t) {
		damon_destroy_ctx(c);
		kunit_skip(test, "third target alloc fail");
	}
	for (i = 0; i < ARRAY_SIZE(sa); i++) {
		r = damon_new_region(sa[i], ea[i]);
		if (!r) {
			damon_free_target(t);
			damon_destroy_ctx(c);
			kunit_skip(test, "region alloc fail");
		}
		damon_add_region(r, t);
	}
	damon_split_regions_of(c, t, 4, 5);
	KUNIT_EXPECT_LE(test, damon_nr_regions(t), 12u);
	damon_for_each_region(r, t)
		KUNIT_EXPECT_GE(test, damon_sz_region(r) % 5ul, 0ul);
	damon_free_target(t);

	damon_destroy_ctx(c);
}

/*
 * When the total region count is already above max_nr_regions / 2,
 * kdamond_split_regions() must keep refining the resolution by splitting a
 * fraction of the regions (making progress), without exceeding
 * max_nr_regions.
 */
static void damon_test_split_above_half_progresses(struct kunit *test)
{
	struct damon_ctx *c;
	struct damon_target *t;
	struct damon_region *r;
	unsigned long start;
	unsigned int nr_before, nr_after, i;
	const unsigned int nr_init = 760;
	const unsigned long region_sz = 100;

	c = damon_new_ctx();
	if (!c)
		kunit_skip(test, "ctx alloc fail");

	/* Keep the split arithmetic independent of the page size */
	c->min_region_sz = 1;
	c->attrs.min_nr_regions = 10;
	c->attrs.max_nr_regions = 1500;

	t = damon_new_target();
	if (!t) {
		damon_destroy_ctx(c);
		kunit_skip(test, "target alloc fail");
	}

	for (i = 0; i < nr_init; i++) {
		start = i * region_sz;
		r = damon_new_region(start, start + region_sz);
		if (!r) {
			damon_free_target(t);
			damon_destroy_ctx(c);
			kunit_skip(test, "region alloc fail");
		}
		r->nr_accesses = (i & 1) ? 0 : 100;
		r->age = 5;
		damon_add_region(r, t);
	}

	damon_add_target(c, t);

	nr_before = damon_nr_regions(t);
	/* Above max_nr_regions / 2, so the blanket-split path is skipped */
	KUNIT_EXPECT_GT(test, (unsigned long)nr_before,
			c->attrs.max_nr_regions / 2);

	kdamond_split_regions(c);

	nr_after = damon_nr_regions(t);
	/* Still made progress ... */
	KUNIT_EXPECT_GT(test, nr_after, nr_before);
	/* ... but did not overshoot the configured maximum */
	KUNIT_EXPECT_LE(test, (unsigned long)nr_after,
			c->attrs.max_nr_regions);

	damon_destroy_ctx(c);
}

static void damon_test_ops_registration(struct kunit *test)
{
	struct damon_ctx *c = damon_new_ctx();
	struct damon_operations ops = {.id = DAMON_OPS_VADDR}, bak;
	bool need_cleanup = false;

	if (!c)
		kunit_skip(test, "ctx alloc fail");

	/* DAMON_OPS_VADDR is registered only if CONFIG_DAMON_VADDR is set */
	if (!damon_is_registered_ops(DAMON_OPS_VADDR)) {
		bak.id = DAMON_OPS_VADDR;
		KUNIT_EXPECT_EQ(test, damon_register_ops(&bak), 0);
		need_cleanup = true;
	}

	/* DAMON_OPS_VADDR is ensured to be registered */
	KUNIT_EXPECT_EQ(test, damon_select_ops(c, DAMON_OPS_VADDR), 0);

	/* Double-registration is prohibited */
	KUNIT_EXPECT_EQ(test, damon_register_ops(&ops), -EINVAL);

	/* Unknown ops id cannot be registered */
	KUNIT_EXPECT_EQ(test, damon_select_ops(c, NR_DAMON_OPS), -EINVAL);

	/* Registration should success after unregistration */
	scoped_guard(mutex, &damon_ops_lock) {
		bak = damon_registered_ops[DAMON_OPS_VADDR];
		damon_registered_ops[DAMON_OPS_VADDR] =
			(struct damon_operations){};
	}

	ops.id = DAMON_OPS_VADDR;
	KUNIT_EXPECT_EQ(test, damon_register_ops(&ops), 0);

	scoped_guard(mutex, &damon_ops_lock)
		damon_registered_ops[DAMON_OPS_VADDR] = bak;

	/* Check double-registration failure again */
	KUNIT_EXPECT_EQ(test, damon_register_ops(&ops), -EINVAL);

	damon_destroy_ctx(c);

	if (need_cleanup) {
		scoped_guard(mutex, &damon_ops_lock)
			damon_registered_ops[DAMON_OPS_VADDR] =
				(struct damon_operations){};
	}
}

static void damon_test_set_regions_for(struct kunit *test,
		struct damon_addr_range *old_ranges, int sz_old_ranges,
		struct damon_addr_range *new_ranges, int sz_new_ranges,
		unsigned long min_region_sz,
		struct damon_addr_range *expect_ranges, int sz_expect_ranges,
		int expect_err)
{
	struct damon_target *t;
	struct damon_region *r;
	int i, err;

	t = damon_new_target();
	if (!t)
		kunit_skip(test, "target alloc fail");
	for (i = 0; i < sz_old_ranges; i++) {
		r = damon_new_region(old_ranges[i].start, old_ranges[i].end);
		if (!r) {
			damon_destroy_target(t, NULL);
			kunit_skip(test, "%d-th r alloc fail\n", i);
		}
		damon_add_region(r, t);
	}

	err = damon_set_regions(t, new_ranges, sz_new_ranges, min_region_sz);
	KUNIT_EXPECT_EQ(test, err, expect_err);

	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), sz_expect_ranges);
	if (damon_nr_regions(t) != sz_expect_ranges) {
		damon_destroy_target(t, NULL);
		return;
	}
	i = 0;
	damon_for_each_region(r, t) {
		KUNIT_EXPECT_EQ(test, r->ar.start, expect_ranges[i].start);
		KUNIT_EXPECT_EQ(test, r->ar.end, expect_ranges[i++].end);
	}

	damon_destroy_target(t, NULL);
}

static void damon_test_set_regions(struct kunit *test)
{
	/* Initial build up on empty target. */
	damon_test_set_regions_for(test,
			(struct damon_addr_range[]){}, 0,
			(struct damon_addr_range[]){
			{.start = 5, .end = 15},
			{.start = 15, .end = 25},
			}, 2,
			1,
			(struct damon_addr_range[]){
			{.start = 5, .end = 15},
			{.start = 15, .end = 25},
			}, 2, 0);
	/* Un-intersecting regions should be removed. */
	damon_test_set_regions_for(test,
			(struct damon_addr_range[]){
			{.start = 4, .end = 16},
			{.start = 24, .end = 32},
			}, 2,
			(struct damon_addr_range[]){
			{.start = 18, .end = 23},
			}, 1,
			1,
			(struct damon_addr_range[]){
			{.start = 18, .end = 23},
			}, 1, 0);
	/*
	 * Holes should be filled up with new regions.
	 *
	 * old:       [4,   16)        [24,     32)
	 * new:         [8,                 28)
	 * expect:      [8, 16)[16,24),[24, 28)
	 */
	damon_test_set_regions_for(test,
			(struct damon_addr_range[]){
			{.start = 4, .end = 16},
			{.start = 24, .end = 32},
			}, 2,
			(struct damon_addr_range[]){
			{.start = 8, .end = 28},
			}, 1,
			1,
			(struct damon_addr_range[]){
			{.start = 8, .end = 16},
			{.start = 16, .end = 24},
			{.start = 24, .end = 28},
			}, 3, 0);
	/*
	 * New regions should be able to be appended.
	 *
	 * old:       [0, 4)[4,    17)
	 * new:       [0,       15)     [25, 40)
	 * expect:    [0, 4)[4, 15)     [25, 40)
	 */
	damon_test_set_regions_for(test,
			(struct damon_addr_range[]){
			{.start = 0, .end = 4},
			{.start = 4, .end = 17},
			}, 2,
			(struct damon_addr_range[]){
			{.start = 0, .end = 15},
			{.start = 25, .end = 40},
			}, 2,
			1,
			(struct damon_addr_range[]){
			{.start = 0, .end = 4},
			{.start = 4, .end = 15},
			{.start = 25, .end = 40},
			}, 3, 0);
	/*
	 * New regions should be able to be inserted.
	 *
	 * old:       [0, 4)                      [42,    52)
	 * new:       [0,       15)     [25, 40)    [44, 50)
	 * expect:    [0,       15)     [25, 40)    [44, 50)
	 */
	damon_test_set_regions_for(test,
			(struct damon_addr_range[]){
			{.start = 0, .end = 4},
			{.start = 42, .end = 52},
			}, 2,
			(struct damon_addr_range[]){
			{.start = 0, .end = 15},
			{.start = 25, .end = 40},
			{.start = 44, .end = 50},
			}, 3,
			1,
			(struct damon_addr_range[]){
			{.start = 0, .end = 15},
			{.start = 25, .end = 40},
			{.start = 44, .end = 50},
			}, 3, 0);
	/* Zero size regions should return -EINVAL. */
	damon_test_set_regions_for(test,
			(struct damon_addr_range[]){}, 0,
			(struct damon_addr_range[]){
			{.start = 42, .end = 42},
			}, 1, 1,
			(struct damon_addr_range[]){}, 0, -EINVAL);
	/* Negative size regions should return -EINVAL. */
	damon_test_set_regions_for(test,
			(struct damon_addr_range[]){}, 0,
			(struct damon_addr_range[]){
			{.start = 42, .end = 21},
			}, 1, 1,
			(struct damon_addr_range[]){}, 0, -EINVAL);
	/*
	 * Regions resulting in same region after alignment should return
	 * -EINVAL.
	 */
	damon_test_set_regions_for(test,
			(struct damon_addr_range[]){}, 0,
			(struct damon_addr_range[]){
			{.start = 10, .end = 20},
			{.start = 20, .end = 30},
			}, 2, 4096,
			(struct damon_addr_range[]){}, 0, -EINVAL);
}

static void damon_test_nr_samples_per_aggr(struct kunit *test)
{
	struct damon_attrs attrs;

	/* Zero sample interval is treated as one. */
	attrs = (struct damon_attrs){
		.sample_interval = 0,
		.aggr_interval = 5000,
	};
	KUNIT_EXPECT_EQ(test, damon_nr_samples_per_aggr(&attrs), 5000);

	/* Zero sample and aggregation intervals cover the zero-result fallback. */
	attrs = (struct damon_attrs){
		.sample_interval = 0,
		.aggr_interval = 0,
	};
	KUNIT_EXPECT_EQ(test, damon_nr_samples_per_aggr(&attrs), 1);

	/*
	 * Too large aggregation interval on 64 bit system doesn't cause
	 * overflow
	 */
	if (ULONG_MAX > UINT_MAX) {
		attrs = (struct damon_attrs){
			.sample_interval = 1,
			.aggr_interval = (unsigned long)UINT_MAX + 1,
		};
		KUNIT_EXPECT_EQ(test, damon_nr_samples_per_aggr(&attrs),
				UINT_MAX);
	}
}

static void damon_test_update_monitoring_result(struct kunit *test)
{
	struct damon_attrs old_attrs = {
		.sample_interval = 10, .aggr_interval = 1000,};
	struct damon_attrs new_attrs;
	struct damon_region *r = damon_new_region(3, 7);
	struct damon_ctx *ctx;

	if (!r)
		kunit_skip(test, "region alloc fail");
	ctx = damon_new_ctx();
	if (!ctx) {
		damon_free_region(r);
		kunit_skip(test, "ctx alloc fail");
	}

	r->nr_accesses = 15;
	r->age = 20;

	new_attrs = (struct damon_attrs){
		.sample_interval = 100, .aggr_interval = 10000,};
	damon_update_monitoring_result(r, &old_attrs, &new_attrs, false, ctx);
	KUNIT_EXPECT_EQ(test, r->nr_accesses, 15);
	KUNIT_EXPECT_EQ(test, r->age, 2);

	new_attrs = (struct damon_attrs){
		.sample_interval = 1, .aggr_interval = 1000};
	damon_update_monitoring_result(r, &old_attrs, &new_attrs, false, ctx);
	KUNIT_EXPECT_EQ(test, r->nr_accesses, 150);
	KUNIT_EXPECT_EQ(test, r->age, 2);

	new_attrs = (struct damon_attrs){
		.sample_interval = 1, .aggr_interval = 100};
	damon_update_monitoring_result(r, &old_attrs, &new_attrs, false, ctx);
	KUNIT_EXPECT_EQ(test, r->nr_accesses, 150);
	KUNIT_EXPECT_EQ(test, r->age, 20);

	damon_free_region(r);
	damon_destroy_ctx(ctx);
}

static void damon_test_set_attrs(struct kunit *test)
{
	struct damon_ctx *c = damon_new_ctx();
	struct damon_attrs valid_attrs = {
		.min_nr_regions = 10, .max_nr_regions = 1000,
		.sample_interval = 5000, .aggr_interval = 100000,};
	struct damon_attrs invalid_attrs;

	if (!c)
		kunit_skip(test, "ctx alloc fail");

	KUNIT_EXPECT_EQ(test, damon_set_attrs(c, &valid_attrs), 0);

	invalid_attrs = valid_attrs;
	invalid_attrs.min_nr_regions = 1;
	KUNIT_EXPECT_EQ(test, damon_set_attrs(c, &invalid_attrs), -EINVAL);

	invalid_attrs = valid_attrs;
	invalid_attrs.max_nr_regions = 9;
	KUNIT_EXPECT_EQ(test, damon_set_attrs(c, &invalid_attrs), -EINVAL);

	invalid_attrs = valid_attrs;
	invalid_attrs.aggr_interval = 4999;
	KUNIT_EXPECT_EQ(test, damon_set_attrs(c, &invalid_attrs), -EINVAL);

	damon_destroy_ctx(c);
}

static void damon_test_mvsum(struct kunit *test)
{
	unsigned long input_expects[] = {
		/* current value, last value, remaining window (bp) */
		0, 49, 10000, 49,	/* 0 + 49 * 1 */
		3, 10, 7000, 10,	/* 3 + 10 * 0.7 */
		3, 10, 5000, 8,		/* 3 + 10 * 0.5 */
		32, 100, 1000, 42,	/* 32 + 100 * 0.1 */
		42, 49, 0, 42,		/* 42 + 49 * 0 */
	};

	int i;

	for (i = 0; i < ARRAY_SIZE(input_expects); i += 4) {
		unsigned long current_nr = input_expects[i];
		unsigned long last_nr = input_expects[i + 1];
		unsigned long left_window_bp = input_expects[i + 2];
		unsigned long expect = input_expects[i + 3];

		KUNIT_EXPECT_EQ(test, damon_mvsum(current_nr, last_nr,
					left_window_bp), expect);
	}
}

/*
 * Test damon_nr_accesses_mvsum(), which wraps damon_mvsum() with the
 * monitoring intervals of the context.  With a sample interval of 1 and an
 * aggregation interval of 10, an aggregation window is 10 sample intervals
 * long.  Each row below specifies the passed sample intervals, the next
 * aggregation time in sample intervals, the current and last nr_accesses of a
 * region, and the expected return value.
 */
static void damon_test_nr_accesses_mvsum(struct kunit *test)
{
	unsigned long input_expects[] = {
		/* passed, next_aggr, nr_accesses, last_nr_accesses, expect */
		0, 10, 5, 3, 3,		/* full window left, unreset */
		0, 10, 0, 7, 7,		/* full window left, reset */
		5, 10, 3, 10, 8,	/* half window left */
		8, 10, 3, 10, 5,	/* 20% window left */
		10, 10, 42, 49, 42,	/* no window left */
	};
	struct damon_ctx *c = damon_new_ctx();
	struct damon_region *r;
	int i;

	if (!c)
		kunit_skip(test, "ctx alloc fail");

	r = damon_new_region(0, 4096);
	if (!r) {
		damon_destroy_ctx(c);
		kunit_skip(test, "region alloc fail");
	}

	c->attrs.sample_interval = 1;
	c->attrs.aggr_interval = 10;

	for (i = 0; i < ARRAY_SIZE(input_expects); i += 5) {
		c->passed_sample_intervals = input_expects[i];
		c->next_aggregation_sis = input_expects[i + 1];
		r->nr_accesses = input_expects[i + 2];
		r->last_nr_accesses = input_expects[i + 3];

		KUNIT_EXPECT_EQ(test, (unsigned int)input_expects[i + 4],
				damon_nr_accesses_mvsum(r, c));
	}

	damon_free_region(r);
	damon_destroy_ctx(c);
}

static void damos_test_new_filter(struct kunit *test)
{
	struct damos_filter *filter;

	filter = damos_new_filter(DAMOS_FILTER_TYPE_ANON, true, false);
	if (!filter)
		kunit_skip(test, "filter alloc fail");
	KUNIT_EXPECT_EQ(test, filter->type, DAMOS_FILTER_TYPE_ANON);
	KUNIT_EXPECT_EQ(test, filter->matching, true);
	KUNIT_EXPECT_PTR_EQ(test, filter->list.prev, &filter->list);
	KUNIT_EXPECT_PTR_EQ(test, filter->list.next, &filter->list);
	damos_destroy_filter(filter);
}

static void damos_test_new_scheme_keeps_src_quota(struct kunit *test)
{
	struct damos_access_pattern pattern = {};
	struct damon_target target = {};
	struct damos_quota quota = {
		.sz = SZ_64K,
		.esz = 123,
		.esz_bp = 456,
		.total_charged_sz = 789,
		.total_charged_ns = 1011,
		.charged_sz = 12,
		.charged_from = 13,
		.charge_target_from = &target,
		.charge_addr_from = 14,
	};
	struct damos_watermarks wmarks = {};
	struct damos *s;

	s = damon_new_scheme(&pattern, DAMOS_STAT, 0, &quota, &wmarks,
			NUMA_NO_NODE);
	if (!s)
		kunit_skip(test, "scheme alloc fail");
	KUNIT_EXPECT_EQ(test, s->quota.sz, (unsigned long)SZ_64K);
	KUNIT_EXPECT_EQ(test, s->quota.esz, 0ul);
	KUNIT_EXPECT_EQ(test, s->quota.esz_bp, 0ul);
	KUNIT_EXPECT_EQ(test, s->quota.total_charged_sz, 0ul);
	KUNIT_EXPECT_EQ(test, s->quota.total_charged_ns, 0ul);
	KUNIT_EXPECT_EQ(test, s->quota.charged_sz, 0ul);
	KUNIT_EXPECT_EQ(test, s->quota.charged_from, 0ul);
	KUNIT_EXPECT_PTR_EQ(test, s->quota.charge_target_from, NULL);
	KUNIT_EXPECT_EQ(test, s->quota.charge_addr_from, 0ul);
	KUNIT_EXPECT_EQ(test, quota.esz, 123ul);
	KUNIT_EXPECT_EQ(test, quota.esz_bp, 456ul);
	KUNIT_EXPECT_EQ(test, quota.total_charged_sz, 789ul);
	KUNIT_EXPECT_EQ(test, quota.total_charged_ns, 1011ul);
	KUNIT_EXPECT_EQ(test, quota.charged_sz, 12ul);
	KUNIT_EXPECT_EQ(test, quota.charged_from, 13ul);
	KUNIT_EXPECT_PTR_EQ(test, quota.charge_target_from, &target);
	KUNIT_EXPECT_EQ(test, quota.charge_addr_from, 14ul);
	damon_destroy_scheme(s);
}

static void damos_test_commit_quota_goal_for(struct kunit *test,
		struct damos_quota_goal *dst,
		struct damos_quota_goal *src)
{
	damos_commit_quota_goal(dst, src);

	KUNIT_EXPECT_EQ(test, dst->metric, src->metric);
	KUNIT_EXPECT_EQ(test, dst->complement, src->complement);
	KUNIT_EXPECT_EQ(test, dst->target_value, src->target_value);
	if (src->metric == DAMOS_QUOTA_USER_INPUT)
		KUNIT_EXPECT_EQ(test, dst->current_value, src->current_value);
	switch (dst->metric) {
	case DAMOS_QUOTA_SOME_MEM_PSI_US:
		KUNIT_EXPECT_EQ(test, dst->last_psi_total, U64_MAX);
		break;
	case DAMOS_QUOTA_NODE_MEM_USED_BP:
	case DAMOS_QUOTA_NODE_MEM_FREE_BP:
		KUNIT_EXPECT_EQ(test, dst->nid, src->nid);
		break;
	case DAMOS_QUOTA_NODE_MEMCG_USED_BP:
	case DAMOS_QUOTA_NODE_MEMCG_FREE_BP:
		KUNIT_EXPECT_EQ(test, dst->nid, src->nid);
		KUNIT_EXPECT_EQ(test, dst->memcg_id, src->memcg_id);
		break;
	case DAMOS_QUOTA_NODE_ELIGIBLE_MEM_BP:
		KUNIT_EXPECT_EQ(test, dst->nid, src->nid);
		break;
	default:
		break;
	}
}

static void damos_test_commit_quota_goal(struct kunit *test)
{
	struct damos_quota_goal dst = {
		.metric = DAMOS_QUOTA_SOME_MEM_PSI_US,
		.target_value = 1000,
		.current_value = 123,
		.last_psi_total = 456,
	};

	damos_test_commit_quota_goal_for(test, &dst,
			&(struct damos_quota_goal) {
			.metric = DAMOS_QUOTA_SOME_MEM_PSI_US,
			.target_value = 234,
			.current_value = 345,
			.last_psi_total = 567,
			});
	damos_test_commit_quota_goal_for(test, &dst,
			&(struct damos_quota_goal){
			.metric = DAMOS_QUOTA_USER_INPUT,
			.complement = true,
			.target_value = 789,
			.current_value = 12});
	damos_test_commit_quota_goal_for(test, &dst,
			&(struct damos_quota_goal){
			.metric = DAMOS_QUOTA_NODE_MEM_FREE_BP,
			.target_value = 345,
			.current_value = 678,
			.nid = 9,
			});
	damos_test_commit_quota_goal_for(test, &dst,
			&(struct damos_quota_goal){
			.metric = DAMOS_QUOTA_NODE_MEM_USED_BP,
			.target_value = 12,
			.current_value = 345,
			.nid = 6,
			});
	damos_test_commit_quota_goal_for(test, &dst,
			&(struct damos_quota_goal){
			.metric = DAMOS_QUOTA_NODE_MEMCG_USED_BP,
			.target_value = 456,
			.current_value = 567,
			.nid = 6,
			.memcg_id = 7,
			});
	damos_test_commit_quota_goal_for(test, &dst,
			&(struct damos_quota_goal){
			.metric = DAMOS_QUOTA_NODE_MEMCG_FREE_BP,
			.target_value = 890,
			.current_value = 901,
			.nid = 10,
			.memcg_id = 1,
			});
	damos_test_commit_quota_goal_for(test, &dst,
			&(struct damos_quota_goal) {
			.metric = DAMOS_QUOTA_SOME_MEM_PSI_US,
			.target_value = 234,
			.current_value = 345,
			.last_psi_total = 567,
			});
	damos_test_commit_quota_goal_for(test, &dst,
			&(struct damos_quota_goal){
			.metric = DAMOS_QUOTA_NODE_ELIGIBLE_MEM_BP,
			.target_value = 12,
			.current_value = 345,
			.nid = 6,
			});
}

static void damos_test_set_psi_current_val(struct kunit *test)
{
	struct damos s = {
		.quota.goal_tuner = DAMOS_QUOTA_GOAL_TUNER_CONSIST,
	};
	struct damos_quota_goal goal = {
		.metric = DAMOS_QUOTA_SOME_MEM_PSI_US,
		.target_value = 100,
		.last_psi_total = U64_MAX,
	};

	/* uninitialized last_psi_total keeps the consist tuner quota */
	damos_set_psi_current_val(1000, &goal, &s);
	KUNIT_EXPECT_EQ(test, goal.current_value, 100ul);
	KUNIT_EXPECT_EQ(test, goal.last_psi_total, 1000ull);

	/* initialized last_psi_total gives the delta */
	damos_set_psi_current_val(1030, &goal, &s);
	KUNIT_EXPECT_EQ(test, goal.current_value, 30ul);
	KUNIT_EXPECT_EQ(test, goal.last_psi_total, 1030ull);

	/* temporal tuner keeps a zero quota */
	s.quota.goal_tuner = DAMOS_QUOTA_GOAL_TUNER_TEMPORAL;
	s.quota.esz = 0;
	goal.last_psi_total = U64_MAX;
	damos_set_psi_current_val(2000, &goal, &s);
	KUNIT_EXPECT_EQ(test, goal.current_value, 100ul);
	KUNIT_EXPECT_EQ(test, goal.last_psi_total, 2000ull);

	/* temporal tuner keeps a non-zero quota */
	s.quota.esz = SZ_64K;
	goal.last_psi_total = U64_MAX;
	damos_set_psi_current_val(3000, &goal, &s);
	KUNIT_EXPECT_EQ(test, goal.current_value, 0ul);
	KUNIT_EXPECT_EQ(test, goal.last_psi_total, 3000ull);

	/* temporal tuner uses the measured PSI delta */
	damos_set_psi_current_val(3250, &goal, &s);
	KUNIT_EXPECT_EQ(test, goal.current_value, 250ul);
	KUNIT_EXPECT_EQ(test, goal.last_psi_total, 3250ull);
}

static void damos_test_commit_quota_goals_for(struct kunit *test,
		struct damos_quota_goal *dst_goals, int nr_dst_goals,
		struct damos_quota_goal *src_goals, int nr_src_goals)
{
	struct damos_quota dst, src;
	struct damos_quota_goal *goal, *next;
	bool skip = true;
	int i;
	int nr_dst = 0, nr_src = 0;

	INIT_LIST_HEAD(&dst.goals);
	INIT_LIST_HEAD(&src.goals);

	for (i = 0; i < nr_dst_goals; i++) {
		/*
		 * When nr_src_goals is smaller than dst_goals,
		 * damos_commit_quota_goals() will kfree() the dst goals.
		 * Make it kfree()-able.
		 */
		goal = damos_new_quota_goal(dst_goals[i].metric,
				dst_goals[i].complement,
				dst_goals[i].target_value);
		if (!goal)
			goto out;
		damos_add_quota_goal(&dst, goal);
	}
	skip = false;
	for (i = 0; i < nr_src_goals; i++)
		damos_add_quota_goal(&src, &src_goals[i]);

	damos_commit_quota_goals(&dst, &src);

	damos_for_each_quota_goal(goal, &dst)
		nr_dst++;
	damos_for_each_quota_goal(goal, &src)
		nr_src++;
	KUNIT_EXPECT_EQ(test, nr_dst, nr_src);
	if (nr_dst != nr_src)
		goto out;

	i = 0;
	damos_for_each_quota_goal(goal, (&dst)) {
		KUNIT_EXPECT_EQ(test, goal->metric, src_goals[i].metric);
		KUNIT_EXPECT_EQ(test, goal->target_value,
				src_goals[i++].target_value);
	}
	KUNIT_EXPECT_EQ(test, i, nr_src_goals);

out:
	damos_for_each_quota_goal_safe(goal, next, (&dst))
		damos_destroy_quota_goal(goal);
	if (skip)
		kunit_skip(test, "goal alloc fail");
}

static void damos_test_commit_quota_goals(struct kunit *test)
{
	damos_test_commit_quota_goals_for(test,
			(struct damos_quota_goal[]){}, 0,
			(struct damos_quota_goal[]){
				{
				.metric = DAMOS_QUOTA_USER_INPUT,
				.target_value = 123,
				},
			}, 1);
	damos_test_commit_quota_goals_for(test,
			(struct damos_quota_goal[]){
				{
				.metric = DAMOS_QUOTA_USER_INPUT,
				.target_value = 234,
				},

			}, 1,
			(struct damos_quota_goal[]){
				{
				.metric = DAMOS_QUOTA_USER_INPUT,
				.target_value = 345,
				},
			}, 1);
	damos_test_commit_quota_goals_for(test,
			(struct damos_quota_goal[]){
				{
				.metric = DAMOS_QUOTA_USER_INPUT,
				.target_value = 456,
				},

			}, 1,
			(struct damos_quota_goal[]){}, 0);
}

static void damos_test_commit_quota(struct kunit *test)
{
	struct damos_quota dst = {
		.reset_interval = 1,
		.ms = 2,
		.sz = 3,
		.goal_tuner = DAMOS_QUOTA_GOAL_TUNER_CONSIST,
		.fail_charge_num = 2,
		.fail_charge_denom = 3,
		.weight_sz = 4,
		.weight_nr_accesses = 5,
		.weight_age = 6,
	};
	struct damos_quota src = {
		.reset_interval = 7,
		.ms = 8,
		.sz = 9,
		.goal_tuner = DAMOS_QUOTA_GOAL_TUNER_TEMPORAL,
		.fail_charge_num = 1,
		.fail_charge_denom = 1024,
		.weight_sz = 10,
		.weight_nr_accesses = 11,
		.weight_age = 12,
	};

	INIT_LIST_HEAD(&dst.goals);
	INIT_LIST_HEAD(&src.goals);

	damos_commit_quota(&dst, &src);

	KUNIT_EXPECT_EQ(test, dst.reset_interval, src.reset_interval);
	KUNIT_EXPECT_EQ(test, dst.ms, src.ms);
	KUNIT_EXPECT_EQ(test, dst.sz, src.sz);
	KUNIT_EXPECT_EQ(test, dst.goal_tuner, src.goal_tuner);
	KUNIT_EXPECT_EQ(test, dst.fail_charge_num, src.fail_charge_num);
	KUNIT_EXPECT_EQ(test, dst.fail_charge_denom, src.fail_charge_denom);
	KUNIT_EXPECT_EQ(test, dst.weight_sz, src.weight_sz);
	KUNIT_EXPECT_EQ(test, dst.weight_nr_accesses, src.weight_nr_accesses);
	KUNIT_EXPECT_EQ(test, dst.weight_age, src.weight_age);
}

static int damos_test_help_dests_setup(struct damos_migrate_dests *dests,
		unsigned int *node_id_arr, unsigned int *weight_arr,
		size_t nr_dests)
{
	size_t i;

	dests->node_id_arr = kmalloc_objs(*dests->node_id_arr, nr_dests);
	if (!dests->node_id_arr)
		return -ENOMEM;
	dests->weight_arr = kmalloc_objs(*dests->weight_arr, nr_dests);
	if (!dests->weight_arr) {
		kfree(dests->node_id_arr);
		dests->node_id_arr = NULL;
		return -ENOMEM;
	}

	for (i = 0; i < nr_dests; i++) {
		dests->node_id_arr[i] = node_id_arr[i];
		dests->weight_arr[i] = weight_arr[i];
	}
	dests->nr_dests = nr_dests;
	return 0;
}

static void damos_test_help_dests_free(struct damos_migrate_dests *dests)
{
	kfree(dests->node_id_arr);
	kfree(dests->weight_arr);
}

static void damos_test_commit_dests_for(struct kunit *test,
		unsigned int *dst_node_id_arr, unsigned int *dst_weight_arr,
		size_t dst_nr_dests,
		unsigned int *src_node_id_arr, unsigned int *src_weight_arr,
		size_t src_nr_dests)
{
	struct damos_migrate_dests dst = {}, src = {};
	int i, err;
	bool skip = true;

	err = damos_test_help_dests_setup(&dst, dst_node_id_arr,
			dst_weight_arr, dst_nr_dests);
	if (err)
		kunit_skip(test, "dests setup fail");
	err = damos_test_help_dests_setup(&src, src_node_id_arr,
			src_weight_arr, src_nr_dests);
	if (err) {
		damos_test_help_dests_free(&dst);
		kunit_skip(test, "src setup fail");
	}
	err = damos_commit_dests(&dst, &src);
	if (err)
		goto out;
	skip = false;

	KUNIT_EXPECT_EQ(test, dst.nr_dests, src_nr_dests);
	if (dst.nr_dests != src_nr_dests)
		goto out;
	for (i = 0; i < dst.nr_dests; i++) {
		KUNIT_EXPECT_EQ(test, dst.node_id_arr[i], src_node_id_arr[i]);
		KUNIT_EXPECT_EQ(test, dst.weight_arr[i], src_weight_arr[i]);
	}

out:
	damos_test_help_dests_free(&dst);
	damos_test_help_dests_free(&src);
	if (skip)
		kunit_skip(test, "skip");
}

static void damos_test_commit_dests(struct kunit *test)
{
	damos_test_commit_dests_for(test,
			(unsigned int[]){1, 2, 3}, (unsigned int[]){2, 3, 4},
			3,
			(unsigned int[]){4, 5, 6}, (unsigned int[]){5, 6, 7},
			3);
	damos_test_commit_dests_for(test,
			(unsigned int[]){1, 2}, (unsigned int[]){2, 3},
			2,
			(unsigned int[]){4, 5, 6}, (unsigned int[]){5, 6, 7},
			3);
	damos_test_commit_dests_for(test,
			NULL, NULL, 0,
			(unsigned int[]){4, 5, 6}, (unsigned int[]){5, 6, 7},
			3);
	damos_test_commit_dests_for(test,
			(unsigned int[]){1, 2, 3}, (unsigned int[]){2, 3, 4},
			3,
			(unsigned int[]){4, 5}, (unsigned int[]){5, 6}, 2);
	damos_test_commit_dests_for(test,
			(unsigned int[]){1, 2, 3}, (unsigned int[]){2, 3, 4},
			3,
			NULL, NULL, 0);
}

static void damos_test_commit_filter_for(struct kunit *test,
		struct damos_filter *dst, struct damos_filter *src,
		bool expect_fail)
{
	int err;

	err = damos_commit_filter(dst, src);
	KUNIT_EXPECT_EQ(test, err != 0, expect_fail);
	if (expect_fail)
		return;
	KUNIT_EXPECT_EQ(test, dst->type, src->type);
	KUNIT_EXPECT_EQ(test, dst->matching, src->matching);
	KUNIT_EXPECT_EQ(test, dst->allow, src->allow);
	switch (src->type) {
	case DAMOS_FILTER_TYPE_MEMCG:
		KUNIT_EXPECT_EQ(test, dst->memcg_id, src->memcg_id);
		break;
	case DAMOS_FILTER_TYPE_ADDR:
		KUNIT_EXPECT_EQ(test, dst->addr_range.start,
				src->addr_range.start);
		KUNIT_EXPECT_EQ(test, dst->addr_range.end,
				src->addr_range.end);
		break;
	case DAMOS_FILTER_TYPE_TARGET:
		KUNIT_EXPECT_EQ(test, dst->target_idx, src->target_idx);
		break;
	case DAMOS_FILTER_TYPE_HUGEPAGE_SIZE:
		KUNIT_EXPECT_EQ(test, dst->sz_range.min, src->sz_range.min);
		KUNIT_EXPECT_EQ(test, dst->sz_range.max, src->sz_range.max);
		break;
	case DAMOS_FILTER_TYPE_PROBE_HITS_WSUM:
		KUNIT_EXPECT_EQ(test, dst->range_min, src->range_min);
		KUNIT_EXPECT_EQ(test, dst->range_max, src->range_max);
		break;
	default:
		break;
	}
}

static void damos_test_commit_filter(struct kunit *test)
{
	struct damos_filter dst = {
		.type = DAMOS_FILTER_TYPE_ACTIVE,
		.matching = false,
		.allow = false,
	};

	damos_test_commit_filter_for(test, &dst,
			&(struct damos_filter){
			.type = DAMOS_FILTER_TYPE_ANON,
			.matching = true,
			.allow = true,
			}, false);
	damos_test_commit_filter_for(test, &dst,
			&(struct damos_filter){
			.type = DAMOS_FILTER_TYPE_MEMCG,
			.matching = false,
			.allow = false,
			.memcg_id = 123,
			}, false);
	damos_test_commit_filter_for(test, &dst,
			&(struct damos_filter){
			.type = DAMOS_FILTER_TYPE_YOUNG,
			.matching = true,
			.allow = true,
			}, false);
	damos_test_commit_filter_for(test, &dst,
			&(struct damos_filter){
			.type = DAMOS_FILTER_TYPE_HUGEPAGE_SIZE,
			.matching = false,
			.allow = false,
			.sz_range = {.min = 234, .max = 345},
			}, false);
	damos_test_commit_filter_for(test, &dst,
			&(struct damos_filter){
			.type = DAMOS_FILTER_TYPE_HUGEPAGE_SIZE,
			.matching = false,
			.allow = false,
			.sz_range = {.min = 456, .max = 123},
			}, true);
	damos_test_commit_filter_for(test, &dst,
			&(struct damos_filter){
			.type = DAMOS_FILTER_TYPE_UNMAPPED,
			.matching = true,
			.allow = true,
			}, false);
	damos_test_commit_filter_for(test, &dst,
			&(struct damos_filter){
			.type = DAMOS_FILTER_TYPE_ADDR,
			.matching = false,
			.allow = false,
			.addr_range = {.start = 456, .end = 567},
			}, false);
	damos_test_commit_filter_for(test, &dst,
			&(struct damos_filter){
			.type = DAMOS_FILTER_TYPE_ADDR,
			.matching = false,
			.allow = false,
			.addr_range = {.start = 567, .end = 456},
			}, true);
	damos_test_commit_filter_for(test, &dst,
			&(struct damos_filter){
			.type = DAMOS_FILTER_TYPE_TARGET,
			.matching = true,
			.allow = true,
			.target_idx = 6,
			}, false);
	damos_test_commit_filter_for(test, &dst,
			&(struct damos_filter){
			.type = DAMOS_FILTER_TYPE_PROBE_HITS_WSUM,
			.matching = false,
			.allow = true,
			.range_min = 12,
			.range_max = 34,
			}, false);
	damos_test_commit_filter_for(test, &dst,
			&(struct damos_filter){
			.type = DAMOS_FILTER_TYPE_PROBE_HITS_WSUM,
			.matching = false,
			.allow = true,
			.range_min = 34,
			.range_max = 12,
			}, true);
}

static void damos_test_help_initailize_scheme(struct damos *scheme)
{
	INIT_LIST_HEAD(&scheme->quota.goals);
	INIT_LIST_HEAD(&scheme->core_filters);
	INIT_LIST_HEAD(&scheme->ops_filters);
}

static void damos_test_commit_for(struct kunit *test, struct damos *dst,
		struct damos *src)
{
	int err;

	damos_test_help_initailize_scheme(dst);
	damos_test_help_initailize_scheme(src);

	err = damos_commit(dst, src);
	if (err)
		kunit_skip(test, "damos_commit fail");

	KUNIT_EXPECT_EQ(test, dst->pattern.min_sz_region,
			src->pattern.min_sz_region);
	KUNIT_EXPECT_EQ(test, dst->pattern.max_sz_region,
			src->pattern.max_sz_region);
	KUNIT_EXPECT_EQ(test, dst->pattern.min_nr_accesses,
			src->pattern.min_nr_accesses);
	KUNIT_EXPECT_EQ(test, dst->pattern.max_nr_accesses,
			src->pattern.max_nr_accesses);
	KUNIT_EXPECT_EQ(test, dst->pattern.min_age_region,
			src->pattern.min_age_region);
	KUNIT_EXPECT_EQ(test, dst->pattern.max_age_region,
			src->pattern.max_age_region);

	KUNIT_EXPECT_EQ(test, dst->action, src->action);
	KUNIT_EXPECT_EQ(test, dst->apply_interval_us, src->apply_interval_us);

	KUNIT_EXPECT_EQ(test, dst->wmarks.metric, src->wmarks.metric);
	KUNIT_EXPECT_EQ(test, dst->wmarks.interval, src->wmarks.interval);
	KUNIT_EXPECT_EQ(test, dst->wmarks.high, src->wmarks.high);
	KUNIT_EXPECT_EQ(test, dst->wmarks.mid, src->wmarks.mid);
	KUNIT_EXPECT_EQ(test, dst->wmarks.low, src->wmarks.low);

	switch (src->action) {
	case DAMOS_MIGRATE_COLD:
	case DAMOS_MIGRATE_HOT:
		KUNIT_EXPECT_EQ(test, dst->target_nid, src->target_nid);
		break;
	default:
		break;
	}
}

static void damos_test_commit_pageout(struct kunit *test)
{
	damos_test_commit_for(test,
			&(struct damos){
				.pattern = (struct damos_access_pattern){
					1, 2, 3, 4, 5, 6},
				.action = DAMOS_PAGEOUT,
				.apply_interval_us = 1000000,
				.wmarks = (struct damos_watermarks){
					DAMOS_WMARK_FREE_MEM_RATE,
					900, 100, 50},
			},
			&(struct damos){
				.pattern = (struct damos_access_pattern){
					2, 3, 4, 5, 6, 7},
				.action = DAMOS_PAGEOUT,
				.apply_interval_us = 2000000,
				.wmarks = (struct damos_watermarks){
					DAMOS_WMARK_FREE_MEM_RATE,
					800, 50, 30},
			});
}

static void damos_test_commit_migrate_hot(struct kunit *test)
{
	damos_test_commit_for(test,
			&(struct damos){
				.pattern = (struct damos_access_pattern){
					1, 2, 3, 4, 5, 6},
				.action = DAMOS_PAGEOUT,
				.apply_interval_us = 1000000,
				.wmarks = (struct damos_watermarks){
					DAMOS_WMARK_FREE_MEM_RATE,
					900, 100, 50},
			},
			&(struct damos){
				.pattern = (struct damos_access_pattern){
					2, 3, 4, 5, 6, 7},
				.action = DAMOS_MIGRATE_HOT,
				.apply_interval_us = 2000000,
				.target_nid = 5,
			});
}

static struct damon_target *damon_test_help_setup_target(
		unsigned long region_start_end[][2], int nr_regions)
{
	struct damon_target *t;
	struct damon_region *r;
	int i;

	t = damon_new_target();
	if (!t)
		return NULL;
	for (i = 0; i < nr_regions; i++) {
		r = damon_new_region(region_start_end[i][0],
				region_start_end[i][1]);
		if (!r) {
			damon_free_target(t);
			return NULL;
		}
		damon_add_region(r, t);
	}
	return t;
}

static void damon_test_commit_target_regions_for(struct kunit *test,
		unsigned long dst_start_end[][2], int nr_dst_regions,
		unsigned long src_start_end[][2], int nr_src_regions,
		unsigned long expect_start_end[][2], int nr_expect_regions)
{
	struct damon_target *dst_target, *src_target;
	struct damon_region *r;
	int i;

	dst_target = damon_test_help_setup_target(dst_start_end, nr_dst_regions);
	if (!dst_target)
		kunit_skip(test, "dst target setup fail");
	src_target = damon_test_help_setup_target(src_start_end, nr_src_regions);
	if (!src_target) {
		damon_free_target(dst_target);
		kunit_skip(test, "src target setup fail");
	}
	damon_commit_target_regions(dst_target, src_target, 1);

	KUNIT_EXPECT_EQ(test, damon_nr_regions(dst_target), nr_expect_regions);
	if (damon_nr_regions(dst_target) != nr_expect_regions)
		goto out;

	i = 0;
	damon_for_each_region(r, dst_target) {
		KUNIT_EXPECT_EQ(test, r->ar.start, expect_start_end[i][0]);
		KUNIT_EXPECT_EQ(test, r->ar.end, expect_start_end[i][1]);
		i++;
	}

out:
	damon_free_target(dst_target);
	damon_free_target(src_target);
}

static void damon_test_commit_target_regions(struct kunit *test)
{
	damon_test_commit_target_regions_for(test,
			(unsigned long[][2]) {{3, 8}, {8, 10}}, 2,
			(unsigned long[][2]) {{4, 6}}, 1,
			(unsigned long[][2]) {{4, 6}}, 1);
	damon_test_commit_target_regions_for(test,
			(unsigned long[][2]) {{3, 8}, {8, 10}}, 2,
			(unsigned long[][2]) {}, 0,
			(unsigned long[][2]) {{3, 8}, {8, 10}}, 2);
}

static void damon_test_commit_filter_for(struct kunit *test,
		struct damon_filter *dst, struct damon_filter *src)
{
	damon_commit_filter(dst, src);
	KUNIT_EXPECT_EQ(test, dst->type, src->type);
	KUNIT_EXPECT_EQ(test, dst->matching, src->matching);
	KUNIT_EXPECT_EQ(test, dst->allow, src->allow);
	switch (src->type) {
	case DAMON_FILTER_TYPE_MEMCG:
		KUNIT_EXPECT_EQ(test, dst->memcg_id, src->memcg_id);
		break;
	default:
		break;
	}
}

static void damon_test_commit_filter(struct kunit *test)
{
	struct damon_filter dst = {
		.type = DAMON_FILTER_TYPE_ANON,
		.matching = false,
		.allow = false,
	};

	damon_test_commit_filter_for(test, &dst,
			&(struct damon_filter){
			.type = DAMON_FILTER_TYPE_ANON,
			.matching = true,
			.allow = true,
			});
	damon_test_commit_filter_for(test, &dst,
			&(struct damon_filter){
			.type = DAMON_FILTER_TYPE_MEMCG,
			.matching = false,
			.allow = false,
			.memcg_id = 123,
			});
}

static struct damon_ctx *damon_test_help_setup_probes(unsigned int weights[],
		int nr_weights)
{
	struct damon_ctx *ctx;
	struct damon_probe *probe;
	int i;

	ctx = damon_new_ctx();
	if (!ctx)
		return NULL;
	for (i = 0; i < nr_weights; i++) {
		probe = damon_new_probe();
		if (!probe) {
			damon_destroy_ctx(ctx);
			return NULL;
		}
		probe->weight = weights[i];
		damon_add_probe(ctx, probe);
	}
	return ctx;
}

static void damon_test_commit_probes_for(struct kunit *test,
		unsigned int dst_weights[], int nr_dst_probes,
		unsigned int src_weights[], int nr_src_probes)
{
	struct damon_ctx *dst, *src;
	int err;
	struct damon_probe *dst_probe, *src_probe;

	dst = damon_test_help_setup_probes(dst_weights, nr_dst_probes);
	if (!dst)
		kunit_skip(test, "dst alloc fail");
	src = damon_test_help_setup_probes(src_weights, nr_src_probes);
	if (!src) {
		damon_destroy_ctx(dst);
		kunit_skip(test, "src alloc fail");
	}

	err = damon_commit_probes(dst, src);
	KUNIT_EXPECT_EQ(test, err, 0);
	if (err)
		goto out;
	nr_dst_probes = 0;
	damon_for_each_probe(dst_probe, dst)
		nr_dst_probes++;
	nr_src_probes = 0;
	damon_for_each_probe(src_probe, src)
		nr_src_probes++;
	KUNIT_EXPECT_EQ(test, nr_dst_probes, nr_src_probes);
	if (nr_dst_probes != nr_src_probes)
		goto out;
	nr_dst_probes = 0;
	damon_for_each_probe(dst_probe, dst) {
		src_probe = damon_nth_probe(nr_dst_probes, src);
		KUNIT_EXPECT_EQ(test, src_probe->weight, dst_probe->weight);
		nr_dst_probes++;
	}
out:
	damon_destroy_ctx(dst);
	damon_destroy_ctx(src);
}

static void damon_test_commit_probes(struct kunit *test)
{
	damon_test_commit_probes_for(test,
			(unsigned int[]){}, 0, (unsigned int[]){}, 0);
	damon_test_commit_probes_for(test,
			(unsigned int[]){}, 0, (unsigned int[]){1}, 1);
	damon_test_commit_probes_for(test,
			(unsigned int[]){}, 0, (unsigned int[]){1, 2}, 2);
	damon_test_commit_probes_for(test,
			(unsigned int[]){1}, 1, (unsigned int[]){2}, 1);
	damon_test_commit_probes_for(test,
			(unsigned int[]){1}, 1, (unsigned int[]){2, 3}, 2);
	damon_test_commit_probes_for(test,
			(unsigned int[]){2, 3}, 2, (unsigned int[]){1}, 1);
	damon_test_commit_probes_for(test,
			(unsigned int[]){2, 3}, 2, (unsigned int[]){}, 0);
	damon_test_commit_probes_for(test,
			(unsigned int[]){2}, 1, (unsigned int[]){}, 0);
}

static void damon_test_commit_ctx(struct kunit *test)
{
	struct damon_ctx *src, *dst;

	src = damon_new_ctx();
	if (!src)
		kunit_skip(test, "src alloc fail");
	dst = damon_new_ctx();
	if (!dst) {
		damon_destroy_ctx(src);
		kunit_skip(test, "dst alloc fail");
	}
	/* Only power of two min_region_sz is allowed. */
	src->min_region_sz = 4096;
	KUNIT_EXPECT_EQ(test, damon_commit_ctx(dst, src), 0);
	src->min_region_sz = 4095;
	KUNIT_EXPECT_EQ(test, damon_commit_ctx(dst, src), -EINVAL);
	src->min_region_sz = 4096;
	src->pause = true;
	KUNIT_EXPECT_EQ(test, damon_commit_ctx(dst, src), 0);
	KUNIT_EXPECT_TRUE(test, dst->pause);
	damon_destroy_ctx(src);
	damon_destroy_ctx(dst);
}

static void damon_test_commit_ctx_keeps_quota_for(struct kunit *test,
		unsigned long min_region_sz, int expected_err)
{
	struct damos_access_pattern pattern = {};
	struct damos_quota quota = {.sz = SZ_64K};
	struct damos_watermarks wmarks = {};
	struct damon_ctx *src, *dst;
	struct damon_target *target;
	struct damos *s;

	dst = damon_new_ctx();
	if (!dst)
		kunit_skip(test, "dst alloc fail");
	target = damon_new_target();
	if (!target) {
		damon_destroy_ctx(dst);
		kunit_skip(test, "target alloc fail");
	}
	damon_add_target(dst, target);
	s = damon_new_scheme(&pattern, DAMOS_STAT, 0, &quota, &wmarks,
			NUMA_NO_NODE);
	if (!s) {
		damon_destroy_ctx(dst);
		kunit_skip(test, "scheme alloc fail");
	}
	damon_add_scheme(dst, s);

	/* Copy the parameters before populating dst's runtime quota state. */
	src = damon_new_test_ctx(dst);
	if (!src) {
		damon_destroy_ctx(dst);
		kunit_skip(test, "src alloc fail");
	}
	src->min_region_sz = min_region_sz;
	s->quota.esz = 123;
	s->quota.esz_bp = 456;
	s->quota.total_charged_sz = 789;
	s->quota.total_charged_ns = 1011;
	s->quota.charged_sz = 12;
	s->quota.charged_from = 13;
	s->quota.charge_target_from = target;
	s->quota.charge_addr_from = 14;

	KUNIT_EXPECT_EQ(test, damon_commit_ctx(dst, src), expected_err);
	KUNIT_EXPECT_EQ(test, s->quota.esz, 123ul);
	KUNIT_EXPECT_EQ(test, s->quota.esz_bp, 456ul);
	KUNIT_EXPECT_EQ(test, s->quota.total_charged_sz, 789ul);
	KUNIT_EXPECT_EQ(test, s->quota.total_charged_ns, 1011ul);
	KUNIT_EXPECT_EQ(test, s->quota.charged_sz, 12ul);
	KUNIT_EXPECT_EQ(test, s->quota.charged_from, 13ul);
	KUNIT_EXPECT_PTR_EQ(test, s->quota.charge_target_from, target);
	KUNIT_EXPECT_EQ(test, s->quota.charge_addr_from, 14ul);
	damon_destroy_ctx(src);
	damon_destroy_ctx(dst);
}

static void damon_test_commit_ctx_keeps_quota(struct kunit *test)
{
	/* Only power of two min_region_sz is allowed. */
	damon_test_commit_ctx_keeps_quota_for(test, 4096, 0);
	damon_test_commit_ctx_keeps_quota_for(test, 4095, -EINVAL);
}

static void damon_test_valid_probe_params(struct kunit *test)
{
	struct damon_ctx *ctx;
	struct damon_probe *probe, *probe2;

	ctx = damon_new_ctx();
	if (!ctx)
		kunit_skip(test, "ctx alloc fail");
	probe = damon_new_probe();
	if (!probe) {
		damon_destroy_ctx(ctx);
		kunit_skip(test, "probe alloc fail");
	}
	damon_add_probe(ctx, probe);

	/* Parameters are validated only if any probe weight is set. */
	ctx->attrs.sample_interval = 1;
	ctx->attrs.aggr_interval = 1000000;
	KUNIT_EXPECT_TRUE(test, damon_valid_probe_params(ctx));

	/* Up to U8_MAX samples per aggregation interval are allowed. */
	probe->weight = 100;
	ctx->attrs.aggr_interval = 255;
	KUNIT_EXPECT_TRUE(test, damon_valid_probe_params(ctx));

	/* More samples could overflow the probe_hits counters. */
	ctx->attrs.aggr_interval = 256;
	KUNIT_EXPECT_FALSE(test, damon_valid_probe_params(ctx));

	/* The largest weight whose weighted hit count fits in unsigned int. */
	ctx->attrs.aggr_interval = 255;
	probe->weight = UINT_MAX / 255;
	KUNIT_EXPECT_TRUE(test, damon_valid_probe_params(ctx));

	/* Any larger weight could overflow its weighted hit count. */
	probe->weight = UINT_MAX / 255 + 1;
	KUNIT_EXPECT_FALSE(test, damon_valid_probe_params(ctx));

	/* With one sample per aggregation, even the largest weight fits. */
	ctx->attrs.aggr_interval = 1;
	probe->weight = UINT_MAX;
	KUNIT_EXPECT_TRUE(test, damon_valid_probe_params(ctx));

	/* The sum of all probes' weighted hit counts could also overflow. */
	probe2 = damon_new_probe();
	if (!probe2) {
		damon_destroy_ctx(ctx);
		kunit_skip(test, "probe2 alloc fail");
	}
	probe2->weight = 1;
	damon_add_probe(ctx, probe2);
	KUNIT_EXPECT_FALSE(test, damon_valid_probe_params(ctx));

	damon_destroy_ctx(ctx);
}

static void damos_test_filter_out(struct kunit *test)
{
	struct damon_target *t;
	struct damon_region *r, *r2;
	struct damos_filter *f;
	int err;

	f = damos_new_filter(DAMOS_FILTER_TYPE_ADDR, true, false);
	if (!f)
		kunit_skip(test, "filter alloc fail");
	f->addr_range = (struct damon_addr_range){.start = 2, .end = 6};

	t = damon_new_target();
	if (!t) {
		damos_destroy_filter(f);
		kunit_skip(test, "target alloc fail");
	}
	r = damon_new_region(3, 5);
	if (!r) {
		damos_destroy_filter(f);
		damon_free_target(t);
		kunit_skip(test, "region alloc fail");
	}
	damon_add_region(r, t);

	/* region in the range */
	KUNIT_EXPECT_TRUE(test, damos_filter_match(NULL, t, r, f, 1, &err));
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 1);

	/* region before the range */
	r->ar.start = 1;
	r->ar.end = 2;
	KUNIT_EXPECT_FALSE(test,
			damos_filter_match(NULL, t, r, f, 1, &err));
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 1);

	/* region after the range */
	r->ar.start = 6;
	r->ar.end = 8;
	KUNIT_EXPECT_FALSE(test,
			damos_filter_match(NULL, t, r, f, 1, &err));
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 1);

	/* region started before the range */
	r->ar.start = 1;
	r->ar.end = 4;
	KUNIT_EXPECT_FALSE(test, damos_filter_match(NULL, t, r, f, 1, &err));
	/* filter should have split the region */
	KUNIT_EXPECT_EQ(test, r->ar.start, 1);
	KUNIT_EXPECT_EQ(test, r->ar.end, 2);
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 2);
	if (damon_nr_regions(t) != 2)
		goto out;
	r2 = damon_next_region(r);
	KUNIT_EXPECT_EQ(test, r2->ar.start, 2);
	KUNIT_EXPECT_EQ(test, r2->ar.end, 4);
	damon_destroy_region(r2, t);

	/* region started in the range */
	r->ar.start = 2;
	r->ar.end = 8;
	KUNIT_EXPECT_TRUE(test,
			damos_filter_match(NULL, t, r, f, 1, &err));
	/* filter should have split the region */
	KUNIT_EXPECT_EQ(test, r->ar.start, 2);
	KUNIT_EXPECT_EQ(test, r->ar.end, 6);
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 2);
	if (damon_nr_regions(t) != 2)
		goto out;
	r2 = damon_next_region(r);
	KUNIT_EXPECT_EQ(test, r2->ar.start, 6);
	KUNIT_EXPECT_EQ(test, r2->ar.end, 8);
	damon_destroy_region(r2, t);

out:
	damon_free_target(t);
	damos_free_filter(f);
}

static unsigned long damos_test_apply_scheme_stub(struct damon_ctx *c,
		struct damon_target *t, struct damon_region *r,
		struct damos *s, unsigned long *sz_filter_passed)
{
	return 0;
}

static void damos_test_apply_scheme_filtered_sz(struct kunit *test)
{
	struct damos_access_pattern pattern = {
		.min_sz_region = 0,
		.max_sz_region = ULONG_MAX,
		.min_nr_accesses = 0,
		.max_nr_accesses = UINT_MAX,
		.min_age_region = 0,
		.max_age_region = UINT_MAX,
	};
	unsigned long min_sz = DAMON_MIN_REGION_SZ;
	struct damos_watermarks wmarks = {};
	struct damos_quota quota = {};
	struct damon_ctx *c;
	struct damon_target *t;
	struct damon_region *r;
	struct damos_filter *f;
	struct damos *s;

	c = damon_new_ctx();
	if (!c)
		kunit_skip(test, "ctx alloc fail");
	c->ops.apply_scheme = damos_test_apply_scheme_stub;

	s = damon_new_scheme(&pattern, DAMOS_STAT, 0, &quota, &wmarks,
			NUMA_NO_NODE);
	if (!s) {
		damon_destroy_ctx(c);
		kunit_skip(test, "scheme alloc fail");
	}
	damon_add_scheme(c, s);

	t = damon_new_target();
	if (!t) {
		damon_destroy_ctx(c);
		kunit_skip(test, "target alloc fail");
	}
	damon_add_target(c, t);

	f = damos_new_filter(DAMOS_FILTER_TYPE_ADDR, true, false);
	if (!f) {
		damon_destroy_ctx(c);
		kunit_skip(test, "filter alloc fail");
	}
	f->addr_range = (struct damon_addr_range){
		.start = 2 * min_sz,
		.end = 8 * min_sz
	};
	damos_add_filter(s, f);
	damos_set_filters_default_reject(s);

	/* reject filter, region starting before the range */
	r = damon_new_region(0, 4 * min_sz);
	if (!r) {
		damon_destroy_ctx(c);
		kunit_skip(test, "region alloc fail");
	}
	damon_add_region(r, t);

	damos_apply_scheme(c, t, r, s);
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 2);
	KUNIT_EXPECT_EQ(test, r->ar.end, 2 * min_sz);
	KUNIT_EXPECT_EQ(test, s->stat.sz_tried, 2 * min_sz);

	if (damon_nr_regions(t) != 2)
		goto out;
	damon_destroy_region(damon_next_region(r), t);
	damon_destroy_region(r, t);
	s->stat = (struct damos_stat){};

	/* allow filter, region starting inside the range */
	f->allow = true;
	damos_set_filters_default_reject(s);
	r = damon_new_region(2 * min_sz, 10 * min_sz);
	if (!r) {
		damon_destroy_ctx(c);
		kunit_skip(test, "region alloc fail");
	}
	damon_add_region(r, t);

	damos_apply_scheme(c, t, r, s);
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 2);
	KUNIT_EXPECT_EQ(test, r->ar.end, 8 * min_sz);
	KUNIT_EXPECT_EQ(test, s->stat.sz_tried, 6 * min_sz);

out:
	damon_destroy_ctx(c);
}

static void damos_test_apply_scheme_filter_sz_unchanged(struct kunit *test)
{
	struct damos_access_pattern pattern = {
		.min_sz_region = 0,
		.max_sz_region = ULONG_MAX,
		.min_nr_accesses = 0,
		.max_nr_accesses = UINT_MAX,
		.min_age_region = 0,
		.max_age_region = UINT_MAX,
	};
	unsigned long min_sz = DAMON_MIN_REGION_SZ;
	struct damos_watermarks wmarks = {};
	struct damos_quota quota = {};
	struct damos_filter *f, *f2;
	struct damon_ctx *c;
	struct damon_target *t;
	struct damon_region *r;
	struct damos *s;

	c = damon_new_ctx();
	if (!c)
		kunit_skip(test, "ctx alloc fail");
	c->ops.apply_scheme = damos_test_apply_scheme_stub;

	s = damon_new_scheme(&pattern, DAMOS_STAT, 0, &quota, &wmarks,
			NUMA_NO_NODE);
	if (!s) {
		damon_destroy_ctx(c);
		kunit_skip(test, "scheme alloc fail");
	}
	damon_add_scheme(c, s);

	t = damon_new_target();
	if (!t) {
		damon_destroy_ctx(c);
		kunit_skip(test, "target alloc fail");
	}
	damon_add_target(c, t);

	f = damos_new_filter(DAMOS_FILTER_TYPE_ADDR, true, false);
	if (!f) {
		damon_destroy_ctx(c);
		kunit_skip(test, "filter alloc fail");
	}
	f->addr_range = (struct damon_addr_range){
		.start = 2 * min_sz, .end = 8 * min_sz};
	damos_add_filter(s, f);
	damos_set_filters_default_reject(s);

	/* wholly inside a reject range: not counted at all */
	r = damon_new_region(4 * min_sz, 6 * min_sz);
	if (!r) {
		damon_destroy_ctx(c);
		kunit_skip(test, "region alloc fail");
	}
	damon_add_region(r, t);

	damos_apply_scheme(c, t, r, s);
	KUNIT_EXPECT_EQ(test, s->stat.nr_tried, 0);
	KUNIT_EXPECT_EQ(test, s->stat.sz_tried, 0);
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 1);

	/* wholly inside an allow range: counted whole, not split */
	f->allow = true;
	damos_set_filters_default_reject(s);

	damos_apply_scheme(c, t, r, s);
	KUNIT_EXPECT_EQ(test, s->stat.sz_tried, 2 * min_sz);
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 1);

	/* two filters, each trimming: the size left after both is counted */
	damon_destroy_region(r, t);
	s->stat = (struct damos_stat){};
	f->allow = false;
	f->addr_range = (struct damon_addr_range){
		.start = 4 * min_sz, .end = 12 * min_sz};
	f2 = damos_new_filter(DAMOS_FILTER_TYPE_ADDR, true, false);
	if (!f2) {
		damon_destroy_ctx(c);
		kunit_skip(test, "filter alloc fail");
	}
	f2->addr_range = (struct damon_addr_range){
		.start = 2 * min_sz, .end = 3 * min_sz};
	damos_add_filter(s, f2);
	damos_set_filters_default_reject(s);

	r = damon_new_region(0, 8 * min_sz);
	if (!r) {
		damon_destroy_ctx(c);
		kunit_skip(test, "region alloc fail");
	}
	damon_add_region(r, t);

	damos_apply_scheme(c, t, r, s);
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 3);
	KUNIT_EXPECT_EQ(test, r->ar.end, 2 * min_sz);
	KUNIT_EXPECT_EQ(test, s->stat.sz_tried, 2 * min_sz);

	/* a core filter that never splits: counted whole */
	damos_destroy_filter(f2);
	damos_destroy_filter(f);
	f = damos_new_filter(DAMOS_FILTER_TYPE_TARGET, true, true);
	if (!f) {
		damon_destroy_ctx(c);
		kunit_skip(test, "filter alloc fail");
	}
	f->target_idx = 0;
	damos_add_filter(s, f);
	damos_set_filters_default_reject(s);
	s->stat = (struct damos_stat){};

	damos_apply_scheme(c, t, r, s);
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 3);
	KUNIT_EXPECT_EQ(test, r->ar.end, 2 * min_sz);
	KUNIT_EXPECT_EQ(test, s->stat.sz_tried, 2 * min_sz);

	damon_destroy_ctx(c);
}

static void damos_test_apply_scheme_quota_sz(struct kunit *test)
{
	struct damos_access_pattern pattern = {
		.min_sz_region = 0,
		.max_sz_region = ULONG_MAX,
		.min_nr_accesses = 0,
		.max_nr_accesses = UINT_MAX,
		.min_age_region = 0,
		.max_age_region = UINT_MAX,
	};
	unsigned long min_sz = DAMON_MIN_REGION_SZ;
	struct damos_watermarks wmarks = {};
	struct damos_quota quota = {};
	struct damon_region *r, *next;
	struct damon_ctx *c;
	struct damon_target *t;
	struct damos *s;

	c = damon_new_ctx();
	if (!c)
		kunit_skip(test, "ctx alloc fail");

	s = damon_new_scheme(&pattern, DAMOS_STAT, 0, &quota, &wmarks,
			NUMA_NO_NODE);
	if (!s) {
		damon_destroy_ctx(c);
		kunit_skip(test, "scheme alloc fail");
	}
	damon_add_scheme(c, s);
	damos_set_filters_default_reject(s);

	t = damon_new_target();
	if (!t) {
		damon_destroy_ctx(c);
		kunit_skip(test, "target alloc fail");
	}
	damon_add_target(c, t);

	/* no apply_scheme operation: the whole region is counted */
	r = damon_new_region(0, 4 * min_sz);
	if (!r) {
		damon_destroy_ctx(c);
		kunit_skip(test, "region alloc fail");
	}
	damon_add_region(r, t);

	damos_apply_scheme(c, t, r, s);
	KUNIT_EXPECT_EQ(test, s->stat.sz_tried, 4 * min_sz);
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 1);

	/* no filter and no quota: the whole region is counted */
	c->ops.apply_scheme = damos_test_apply_scheme_stub;
	s->stat = (struct damos_stat){};

	damos_apply_scheme(c, t, r, s);
	KUNIT_EXPECT_EQ(test, s->stat.sz_tried, 4 * min_sz);
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 1);

	/* the quota trims the region: the trimmed size is counted */
	damon_for_each_region_safe(r, next, t)
		damon_destroy_region(r, t);
	s->stat = (struct damos_stat){};
	s->quota.esz = 2 * min_sz;
	s->quota.charged_sz = 0;

	r = damon_new_region(0, 8 * min_sz);
	if (!r) {
		damon_destroy_ctx(c);
		kunit_skip(test, "region alloc fail");
	}
	damon_add_region(r, t);

	damos_apply_scheme(c, t, r, s);
	KUNIT_EXPECT_EQ(test, r->ar.end, 2 * min_sz);
	KUNIT_EXPECT_EQ(test, s->stat.sz_tried, 2 * min_sz);

	/* quota remainder below one region: tried, but nothing counted */
	damon_for_each_region_safe(r, next, t)
		damon_destroy_region(r, t);
	s->stat = (struct damos_stat){};
	s->quota.esz = 1;
	s->quota.charged_sz = 0;

	r = damon_new_region(0, 4 * min_sz);
	if (!r) {
		damon_destroy_ctx(c);
		kunit_skip(test, "region alloc fail");
	}
	damon_add_region(r, t);

	damos_apply_scheme(c, t, r, s);
	KUNIT_EXPECT_EQ(test, s->stat.nr_tried, 1);
	KUNIT_EXPECT_EQ(test, s->stat.sz_tried, 0);
	KUNIT_EXPECT_EQ(test, r->ar.end, 4 * min_sz);

	damon_destroy_ctx(c);
}

static void damon_test_feed_loop_next_input(struct kunit *test)
{
	unsigned long last_input = 900000, current_score = 200;

	/*
	 * If current score is lower than the goal, which is always 10,000
	 * (read the comment on damon_feed_loop_next_input()'s comment), next
	 * input should be higher than the last input.
	 */
	KUNIT_EXPECT_GT(test,
			damon_feed_loop_next_input(last_input, current_score),
			last_input);

	/*
	 * If current score is higher than the goal, next input should be lower
	 * than the last input.
	 */
	current_score = 250000000;
	KUNIT_EXPECT_LT(test,
			damon_feed_loop_next_input(last_input, current_score),
			last_input);

	/*
	 * The next input depends on the distance between the current score and
	 * the goal
	 */
	KUNIT_EXPECT_GT(test,
			damon_feed_loop_next_input(last_input, 200),
			damon_feed_loop_next_input(last_input, 2000));
}

static void damon_test_set_filters_default_reject(struct kunit *test)
{
	struct damos scheme;
	struct damos_filter *target_filter, *anon_filter;

	INIT_LIST_HEAD(&scheme.core_filters);
	INIT_LIST_HEAD(&scheme.ops_filters);

	damos_set_filters_default_reject(&scheme);
	/*
	 * No filter is installed.  Allow by default on both core and ops layer
	 * filtering stages, since there are no filters at all.
	 */
	KUNIT_EXPECT_EQ(test, scheme.core_filters_default_reject, false);
	KUNIT_EXPECT_EQ(test, scheme.ops_filters_default_reject, false);

	target_filter = damos_new_filter(DAMOS_FILTER_TYPE_TARGET, true, true);
	if (!target_filter)
		kunit_skip(test, "filter alloc fail");
	damos_add_filter(&scheme, target_filter);
	damos_set_filters_default_reject(&scheme);
	/*
	 * A core-handled allow-filter is installed.
	 * Reject by default on core layer filtering stage due to the last
	 * core-layer-filter's behavior.
	 * Allow by default on ops layer filtering stage due to the absence of
	 * ops layer filters.
	 */
	KUNIT_EXPECT_EQ(test, scheme.core_filters_default_reject, true);
	KUNIT_EXPECT_EQ(test, scheme.ops_filters_default_reject, false);

	target_filter->allow = false;
	damos_set_filters_default_reject(&scheme);
	/*
	 * A core-handled reject-filter is installed.
	 * Allow by default on core layer filtering stage due to the last
	 * core-layer-filter's behavior.
	 * Allow by default on ops layer filtering stage due to the absence of
	 * ops layer filters.
	 */
	KUNIT_EXPECT_EQ(test, scheme.core_filters_default_reject, false);
	KUNIT_EXPECT_EQ(test, scheme.ops_filters_default_reject, false);

	anon_filter = damos_new_filter(DAMOS_FILTER_TYPE_ANON, true, true);
	if (!anon_filter) {
		damos_free_filter(target_filter);
		kunit_skip(test, "anon_filter alloc fail");
	}
	damos_add_filter(&scheme, anon_filter);

	damos_set_filters_default_reject(&scheme);
	/*
	 * A core-handled reject-filter and ops-handled allow-filter are installed.
	 * Allow by default on core layer filtering stage due to the existence
	 * of the ops-handled filter.
	 * Reject by default on ops layer filtering stage due to the last
	 * ops-layer-filter's behavior.
	 */
	KUNIT_EXPECT_EQ(test, scheme.core_filters_default_reject, false);
	KUNIT_EXPECT_EQ(test, scheme.ops_filters_default_reject, true);

	target_filter->allow = true;
	damos_set_filters_default_reject(&scheme);
	/*
	 * A core-handled allow-filter and ops-handled allow-filter are
	 * installed.
	 * Allow by default on core layer filtering stage due to the existence
	 * of the ops-handled filter.
	 * Reject by default on ops layer filtering stage due to the last
	 * ops-layer-filter's behavior.
	 */
	KUNIT_EXPECT_EQ(test, scheme.core_filters_default_reject, false);
	KUNIT_EXPECT_EQ(test, scheme.ops_filters_default_reject, true);

	damos_free_filter(anon_filter);
	damos_free_filter(target_filter);
}

static void damon_test_apply_min_nr_regions_for(struct kunit *test,
		unsigned long sz_regions, unsigned long min_region_sz,
		unsigned long min_nr_regions,
		unsigned long max_region_sz_expect,
		unsigned long nr_regions_expect)
{
	struct damon_ctx *ctx;
	struct damon_target *t;
	struct damon_region *r;
	unsigned long max_region_size;

	ctx = damon_new_ctx();
	if (!ctx)
		kunit_skip(test, "ctx alloc fail\n");
	t = damon_new_target();
	if (!t) {
		damon_destroy_ctx(ctx);
		kunit_skip(test, "target alloc fail\n");
	}
	damon_add_target(ctx, t);
	r = damon_new_region(0, sz_regions);
	if (!r) {
		damon_destroy_ctx(ctx);
		kunit_skip(test, "region alloc fail\n");
	}
	damon_add_region(r, t);

	ctx->min_region_sz = min_region_sz;
	ctx->attrs.min_nr_regions = min_nr_regions;
	max_region_size = damon_apply_min_nr_regions(ctx);

	KUNIT_EXPECT_EQ(test, max_region_size, max_region_sz_expect);
	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), nr_regions_expect);

	damon_destroy_ctx(ctx);
}

static void damon_test_apply_min_nr_regions(struct kunit *test)
{
	/* common, expected setup */
	damon_test_apply_min_nr_regions_for(test, 10, 1, 10, 1, 10);
	/* no zero size limit */
	damon_test_apply_min_nr_regions_for(test, 10, 1, 15, 1, 10);
	/* max size should be aligned by min_region_sz */
	damon_test_apply_min_nr_regions_for(test, 10, 2, 2, 6, 2);
	/*
	 * when min_nr_regions and min_region_sz conflicts, min_region_sz wins.
	 */
	damon_test_apply_min_nr_regions_for(test, 10, 2, 10, 2, 5);
}

static void damon_test_is_last_region(struct kunit *test)
{
	struct damon_region *r;
	struct damon_target *t;
	int i;

	t = damon_new_target();
	if (!t)
		kunit_skip(test, "target alloc fail\n");

	for (i = 0; i < 4; i++) {
		r = damon_new_region(i * 2, (i + 1) * 2);
		if (!r) {
			damon_free_target(t);
			kunit_skip(test, "region alloc %d fail\n", i);
		}
		damon_add_region(r, t);
		KUNIT_EXPECT_TRUE(test, damon_is_last_region(r, t));
	}
	damon_free_target(t);
}

/*
 * Verify that damos_walk() rejects new requests when
 * walk_control_obsolete is set.
 *
 * This tests the invariant introduced by:
 * commit 33c3f6c2b48c ("mm/damon/core: fix damos_walk() vs kdamond_fn() exit race")
 */
static void damon_test_walk_control_obsolete(struct kunit *test)
{
	struct damon_ctx *ctx;
	struct damos_walk_control control = {};
	int ret;

	ctx = damon_new_ctx();
	if (!ctx)
		kunit_skip(test, "ctx alloc fail");

	/* Simulate shutdown phase */
	ctx->walk_control_obsolete = true;

	ret = damos_walk(ctx, &control);

	KUNIT_EXPECT_EQ(test, ret, -ECANCELED);

	damon_destroy_ctx(ctx);
}

static void damon_test_rand(struct kunit *test)
{
	struct damon_ctx ctx;
	int i;

	prandom_seed_state(&ctx.rnd_state, get_random_u64());
	for (i = 0; i < 10000; i++) {
		unsigned long rnd = damon_rand(&ctx, 0, 10);

		KUNIT_EXPECT_GE(test, rnd, 0);
		KUNIT_EXPECT_LE(test, rnd, 9);
	}
}

static void damos_test_esz_goal_temporal(struct kunit *test)
{
	struct damos_access_pattern pattern = {};
	struct damos_watermarks wmarks = {};
	struct damos_quota quota = {
		.goal_tuner = DAMOS_QUOTA_GOAL_TUNER_TEMPORAL,
	};
	struct damos_quota_goal *goal;
	struct damon_ctx *ctx;
	struct damos *s;

	ctx = damon_new_ctx();
	KUNIT_ASSERT_NOT_NULL(test, ctx);

	s = damon_new_scheme(&pattern, DAMOS_STAT, 0, &quota, &wmarks,
			NUMA_NO_NODE);
	if (!s) {
		damon_destroy_ctx(ctx);
		kunit_skip(test, "scheme alloc fail");
	}
	damon_add_scheme(ctx, s);

	goal = damos_new_quota_goal(DAMOS_QUOTA_USER_INPUT, false, 10000);
	if (!goal) {
		damon_destroy_ctx(ctx);
		kunit_skip(test, "quota goal alloc fail");
	}
	goal->current_value = 0;
	damos_add_quota_goal(&s->quota, goal);

	/* The largest size quota the basis-point conversion can hold. */
	s->quota.sz = ULONG_MAX / 10000;
	damos_set_effective_quota(ctx, s);
	KUNIT_EXPECT_EQ(test, s->quota.esz, ULONG_MAX / 10000);

	/* Any larger one saturates instead of wrapping. */
	s->quota.sz = ULONG_MAX / 10000 + 1;
	damos_set_effective_quota(ctx, s);
	KUNIT_EXPECT_EQ(test, s->quota.esz, ULONG_MAX / 10000);

	s->quota.sz = ULONG_MAX;
	damos_set_effective_quota(ctx, s);
	KUNIT_EXPECT_EQ(test, s->quota.esz, ULONG_MAX / 10000);

	damon_destroy_ctx(ctx);
}

static void damon_test_last_region_quota_reset(struct kunit *test)
{
	struct damos s = {0};
	struct damon_target *t;
	struct damon_region *r1, *r2;
	unsigned long min_region_sz = 1;
	bool skipped;

	t = damon_new_target();
	if (!t)
		kunit_skip(test, "target alloc fail");

	r1 = damon_new_region(0, 100);
	if (!r1) {
		damon_free_target(t);
		kunit_skip(test, "region 1 alloc fail");
	}
	damon_add_region(r1, t);

	r2 = damon_new_region(100, 200);
	if (!r2) {
		damon_free_target(t);
		kunit_skip(test, "region 2 alloc fail");
	}
	damon_add_region(r2, t);

	s.quota.charge_target_from = t;
	s.quota.charge_addr_from = r1->ar.end;

	skipped = damos_skip_charged_region(t, r2, &s, min_region_sz);

	/* 'r2' is not processed, it should not skip */
	KUNIT_EXPECT_EQ(test, skipped, false);

	/* 'r2' is last region, it should reset charge_{target,addr}_from */
	KUNIT_EXPECT_PTR_EQ(test, s.quota.charge_target_from, NULL);
	KUNIT_EXPECT_EQ(test, s.quota.charge_addr_from, 0);

	damon_free_target(t);
}

static struct kunit_case damon_test_cases[] = {
	KUNIT_CASE(damon_test_target),
	KUNIT_CASE(damon_test_regions),
	KUNIT_CASE(damon_test_aggregate),
	KUNIT_CASE(damon_test_split_at),
	KUNIT_CASE(damon_test_merge_two),
	KUNIT_CASE(damon_test_merge_regions_of),
	KUNIT_CASE(damon_test_split_regions_of),
	KUNIT_CASE(damon_test_split_above_half_progresses),
	KUNIT_CASE(damon_test_ops_registration),
	KUNIT_CASE(damon_test_set_regions),
	KUNIT_CASE(damon_test_nr_samples_per_aggr),
	KUNIT_CASE(damon_test_update_monitoring_result),
	KUNIT_CASE(damon_test_set_attrs),
	KUNIT_CASE(damon_test_mvsum),
	KUNIT_CASE(damon_test_nr_accesses_mvsum),
	KUNIT_CASE(damos_test_new_filter),
	KUNIT_CASE(damos_test_new_scheme_keeps_src_quota),
	KUNIT_CASE(damos_test_commit_quota_goal),
	KUNIT_CASE(damos_test_set_psi_current_val),
	KUNIT_CASE(damos_test_commit_quota_goals),
	KUNIT_CASE(damos_test_commit_quota),
	KUNIT_CASE(damos_test_commit_dests),
	KUNIT_CASE(damos_test_commit_filter),
	KUNIT_CASE(damos_test_commit_pageout),
	KUNIT_CASE(damos_test_commit_migrate_hot),
	KUNIT_CASE(damon_test_commit_target_regions),
	KUNIT_CASE(damon_test_commit_filter),
	KUNIT_CASE(damon_test_commit_probes),
	KUNIT_CASE(damon_test_commit_ctx),
	KUNIT_CASE(damon_test_commit_ctx_keeps_quota),
	KUNIT_CASE(damon_test_valid_probe_params),
	KUNIT_CASE(damos_test_filter_out),
	KUNIT_CASE(damos_test_apply_scheme_filtered_sz),
	KUNIT_CASE(damos_test_apply_scheme_filter_sz_unchanged),
	KUNIT_CASE(damos_test_apply_scheme_quota_sz),
	KUNIT_CASE(damon_test_feed_loop_next_input),
	KUNIT_CASE(damon_test_set_filters_default_reject),
	KUNIT_CASE(damon_test_apply_min_nr_regions),
	KUNIT_CASE(damon_test_is_last_region),
	KUNIT_CASE(damon_test_walk_control_obsolete),
	KUNIT_CASE(damon_test_rand),
	KUNIT_CASE(damos_test_esz_goal_temporal),
	KUNIT_CASE(damon_test_last_region_quota_reset),
	{},
};

static struct kunit_suite damon_test_suite = {
	.name = "damon",
	.test_cases = damon_test_cases,
};
kunit_test_suite(damon_test_suite);

#endif /* _DAMON_CORE_TEST_H */

#endif	/* CONFIG_DAMON_KUNIT_TEST */