mm/damon: extend DAMOS filters for inclusion
Subsystems (4)
SeongJae Park
maintainerv2 cover mm/damon: extend DAMOS filters for inclusion
DAMOS fitlers are exclusive filters. It only excludes memory of given criterias from the DAMOS action targets. This has below limitations.
First, the name is not explicitly explaining the behavior. This actually resulted in users' confusions[1]. Secondly, combined uses of multiple filters provide only restriced coverages. For example, building a DAMOS scheme that applies the action to memory that belongs to cgroup A "or" cgroup B is impossible. A workaround would be using two schemes that fitlers out memory that not belong to cgroup A and cgroup B, respectively. It is cumbersome, and difficult to control quota-like per-scheme features in an orchestration. Monitoring of filters-passed memory statistic will also be complicated.
Extend DAMOS filters to support not only exclusion (rejecting), but also inclusion (allowing) behavior. For this, add a new damos_filter struct field called 'allow' for DAMON kernel API users. The filter works as an inclusion or exclusion filter when it is set or unset, respectively. For DAMON user-space ABI users, add a DAMON sysfs file of same name under DAMOS filter sysfs directory. To prevent exposing a behavioral change to old users, set rejecting as the default behavior.
Note that allow-filters work for only inclusion, not exclusion of memory that not satisfying the criteria. And the default behavior of DAMOS for memory that no filter has involved is that the action can be applied to those memory. Also, filters-passed memory statistics are for any memory that passed through the DAMOS filters check stage. These implies installing allow-filters at the endof the filter list is useless. Refer to the design doc change of this series for more details.
[1] https://lore.kernel.org/[email protected]
Revision History
================
Changes from v1
(https://lore.kernel.org/[email protected])
- Correct wrong comments and documents about pass filters without successing block filters
- Rename 'pass/block' to 'allow/reject'
(to avoid confusion with sz_[ops]_filter_pass)
Changes from RFC v2
(https://lore.kernel.org/[email protected])
- Wordsmith messages
- Wordsmith design documentation about monitoring-purpose usage
- Rebase on latest mm-unstable
Changes from RFC v1
(https://lore.kernel.org/[email protected])
- Fix encoding issue on the last patch
SeongJae Park (10):
mm/damon: fixup damos_filter kernel-doc
mm/damon/core: add damos_filter->allow field mm/damon/core: support damos_filter->allow
mm/damon/paddr: support damos_filter->allow
mm/damon: add 'allow' argument to damos_new_filter() mm/damon/sysfs-schemes: add a file for setting damos_filter->allow Docs/mm/damon/design: document allow/reject DAMOS filter behaviors Docs/ABI/damon: document DAMOS filter allow sysfs file Docs/admin-guide/mm/damon/usage: omit DAMOS filter details in favor of
design doc
Docs/admin-guide/mm/damon/usage: document DAMOS filter 'allow' sysfs
file
.../ABI/testing/sysfs-kernel-mm-damon | 13 +++-- Documentation/admin-guide/mm/damon/usage.rst | 54 ++++++++++--------- Documentation/mm/damon/design.rst | 33 ++++++++++-- include/linux/damon.h | 15 +++--- mm/damon/core.c | 12 +++-- mm/damon/paddr.c | 9 ++-- mm/damon/reclaim.c | 2 +- mm/damon/sysfs-schemes.c | 32 ++++++++++- mm/damon/tests/core-kunit.h | 14 ++--- 9 files changed, 127 insertions(+), 57 deletions(-)
Signature · 1 line
2.39.5
SeongJae Park
maintainerPATCH v2 1/10 mm/damon: fixup damos_filter kernel-doc
The comment is slightly wrong. DAMOS filters are not only for pages, but general bytes of memory. Also the description of 'matching' is bit confusing, since DAMOS filters do only filtering out. Update the comments to be less confusing.
--- include/linux/damon.h | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
include/linux/damon.h +6 -5
@@ -347,8 +347,8 @@ enum damos_filter_type {/** * struct damos_filter - DAMOS action target memory filter. -* @type: Type of the page. -* @matching: If the matching page should filtered out or in. +* @type: Type of the target memory. +* @matching: If the @type-matching memory should be filtered out. * @memcg_id: Memcg id of the question if @type is DAMOS_FILTER_MEMCG. * @addr_range: Address range if @type is DAMOS_FILTER_TYPE_ADDR. * @target_idx: Index of the &struct damon_target of
@@ -357,9 +357,10 @@ enum damos_filter_type {* @list: List head for siblings. * * Before applying the &damos->action to a memory region, DAMOS checks if each -* page of the region matches to this and avoid applying the action if so. -* Support of each filter type depends on the running &struct damon_operations -* and the type. Refer to &enum damos_filter_type for more detai. +* byte of the region matches to this given condition and avoid applying the +* action if so. Support of each filter type depends on the running &struct +* damon_operations and the type. Refer to &enum damos_filter_type for more +* details. */ struct damos_filter {enum damos_filter_type type;
Signature · 1 line
2.39.5
SeongJae Park
maintainerPATCH v2 2/10 mm/damon/core: add damos_filter->allow field
In reply to SeongJae ParkDAMOS filters work as only exclusive (reject) filters. This makes it easy to be confused, and restrictive at combining multiple filters for covering various types of memory.
Add a field named 'allow' to damos_filter. The field will be used to indicate whether the filter should work for inclusion or exclusion. To keep the old behavior, set it as 'false' (work as exclusive filter) by default, from damos_new_filter().
Following two commits will make the core and operations set layers, which handles damos_filter objects, respect the field, respectively.
--- include/linux/damon.h | 4 +++- mm/damon/core.c | 1 + 2 files changed, 4 insertions(+), 1 deletion(-)
include/linux/damon.h +3 -1
@@ -348,7 +348,8 @@ enum damos_filter_type {/** * struct damos_filter - DAMOS action target memory filter. * @type: Type of the target memory. -* @matching: If the @type-matching memory should be filtered out. +* @matching: Whether this is for @type-matching memory. +* @allow: Whether to include or exclude the @matching memory. * @memcg_id: Memcg id of the question if @type is DAMOS_FILTER_MEMCG. * @addr_range: Address range if @type is DAMOS_FILTER_TYPE_ADDR. * @target_idx: Index of the &struct damon_target of
@@ -365,6 +366,7 @@ enum damos_filter_type {struct damos_filter {enum damos_filter_type type;bool matching; +bool allow;union {unsigned short memcg_id;struct damon_addr_range addr_range;
mm/damon/core.c +1 -0
@@ -275,6 +275,7 @@ struct damos_filter *damos_new_filter(enum damos_filter_type type,return NULL ; filter->type = type; filter->matching = matching; + filter->allow = false;INIT_LIST_HEAD (&filter->list);return filter; }
Signature · 1 line
2.39.5
SeongJae Park
maintainerPATCH v2 3/10 mm/damon/core: support damos_filter->allow
In reply to SeongJae ParkDAMOS filters supports allowing behavior, but the core layer's DAMOS filters handling logic still assumes only rejecting (filtering-out) behavior. Update the logic to aware of and respect the behavioral decision by reading damos_filter->allow when making the decision to exclude a region or not.
--- mm/damon/core.c | 6 +++--- mm/damon/tests/core-kunit.h | 10 +++++----- 2 files changed, 8 insertions(+), 8 deletions(-)
mm/damon/core.c +3 -3
@@ -1374,7 +1374,7 @@ static void damos_update_stat(struct damos *s, s->stat.sz_ops_filter_passed += sz_ops_filter_passed; } -static bool __damos_filter_out (struct damon_ctx *ctx,struct damon_target *t, +static bool damos_filter_match (struct damon_ctx *ctx,struct damon_target *t,struct damon_region *r,struct damos_filter *filter) {bool matched = false;
@@ -1428,8 +1428,8 @@ static bool damos_filter_out(struct damon_ctx *ctx, struct damon_target *t,struct damos_filter *filter;damos_for_each_filter (filter, s) { -if (__damos_filter_out (ctx, t, r, filter)) -return true; +if (damos_filter_match (ctx, t, r, filter)) +return !filter->allow; }return false; }
mm/damon/tests/core-kunit.h +5 -5
@@ -434,25 +434,25 @@ static void damos_test_filter_out(struct kunit *test)damon_add_region (r, t);/* region in the range */ -KUNIT_EXPECT_TRUE (test,__damos_filter_out (NULL , t, r, f)); +KUNIT_EXPECT_TRUE (test,damos_filter_match (NULL , t, r, f));KUNIT_EXPECT_EQ (test,damon_nr_regions (t),1 );/* region before the range */ r->ar.start =DAMON_MIN_REGION *1 ; r->ar.end =DAMON_MIN_REGION *2 ; -KUNIT_EXPECT_FALSE (test,__damos_filter_out (NULL , t, r, f)); +KUNIT_EXPECT_FALSE (test,damos_filter_match (NULL , t, r, f));KUNIT_EXPECT_EQ (test,damon_nr_regions (t),1 );/* region after the range */ r->ar.start =DAMON_MIN_REGION *6 ; r->ar.end =DAMON_MIN_REGION *8 ; -KUNIT_EXPECT_FALSE (test,__damos_filter_out (NULL , t, r, f)); +KUNIT_EXPECT_FALSE (test,damos_filter_match (NULL , t, r, f));KUNIT_EXPECT_EQ (test,damon_nr_regions (t),1 );/* region started before the range */ r->ar.start =DAMON_MIN_REGION *1 ; r->ar.end =DAMON_MIN_REGION *4 ; -KUNIT_EXPECT_FALSE (test,__damos_filter_out (NULL , t, r, f)); +KUNIT_EXPECT_FALSE (test,damos_filter_match (NULL , t, r, f));/* filter should have split the region */ KUNIT_EXPECT_EQ (test, r->ar.start,DAMON_MIN_REGION *1 );KUNIT_EXPECT_EQ (test, r->ar.end,DAMON_MIN_REGION *2 );
@@ -465,7 +465,7 @@ static void damos_test_filter_out(struct kunit *test)/* region started in the range */ r->ar.start =DAMON_MIN_REGION *2 ; r->ar.end =DAMON_MIN_REGION *8 ; -KUNIT_EXPECT_TRUE (test,__damos_filter_out (NULL , t, r, f)); +KUNIT_EXPECT_TRUE (test,damos_filter_match (NULL , t, r, f));/* filter should have split the region */ KUNIT_EXPECT_EQ (test, r->ar.start,DAMON_MIN_REGION *2 );KUNIT_EXPECT_EQ (test, r->ar.end,DAMON_MIN_REGION *6 );
Signature · 1 line
2.39.5
SeongJae Park
maintainerPATCH v2 4/10 mm/damon/paddr: support damos_filter->allow
In reply to SeongJae ParkRespect damos_filter->allow from 'paddr', which is a DAMON operations set implementation for the physical address space and supports a few types of region-internal DAMOS filters (anon, memcg and young). The change is similar to that of the previous commit for core layer update.
--- mm/damon/paddr.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
mm/damon/paddr.c +3 -3
@@ -198,7 +198,7 @@ static unsigned int damon_pa_check_accesses(struct damon_ctx *ctx)return max_nr_accesses; } -static bool __damos_pa_filter_out (struct damos_filter *filter, +static bool damos_pa_filter_match (struct damos_filter *filter,struct folio *folio) {bool matched = false;
@@ -237,8 +237,8 @@ static bool damos_pa_filter_out(struct damos *scheme, struct folio *folio)struct damos_filter *filter;damos_for_each_filter (filter, scheme) { -if (__damos_pa_filter_out (filter, folio)) -return true; +if (damos_pa_filter_match (filter, folio)) +return !filter->allow; }return false; }
Signature · 1 line
2.39.5
SeongJae Park
maintainerPATCH v2 5/10 mm/damon: add 'allow' argument to damos_new_filter()
In reply to SeongJae ParkDAMON API users should set damos_filter->allow manually to use a DAMOS allow-filter, since damos_new_filter() unsets the field always. It is cumbersome and easy to mistake. Add an arugment for setting the field to damos_new_filter().
--- include/linux/damon.h | 2 +- mm/damon/core.c | 7 ++++--- mm/damon/paddr.c | 3 ++- mm/damon/reclaim.c | 2 +- mm/damon/sysfs-schemes.c | 2 +- mm/damon/tests/core-kunit.h | 4 ++-- 6 files changed, 11 insertions(+), 9 deletions(-)
include/linux/damon.h +1 -1
@@ -801,7 +801,7 @@ void damon_update_region_access_rate(struct damon_region *r, bool accessed, struct damon_attrs *attrs);struct damos_filter *damos_new_filter (enum damos_filter_type type, -bool matching); +bool matching,bool allow);void damos_add_filter (struct damos *s,struct damos_filter *f);void damos_destroy_filter (struct damos_filter *f);
mm/damon/core.c +4 -3
@@ -266,7 +266,7 @@ int damon_set_regions(struct damon_target *t, struct damon_addr_range *ranges, }struct damos_filter *damos_new_filter (enum damos_filter_type type, -bool matching) +bool matching,bool allow) {struct damos_filter *filter;
@@ -275,7 +275,7 @@ struct damos_filter *damos_new_filter(enum damos_filter_type type,return NULL ; filter->type = type; filter->matching = matching; - filter->allow = false; + filter->allow = allow;INIT_LIST_HEAD (&filter->list);return filter; }
@@ -806,7 +806,8 @@ static int damos_commit_filters(struct damos *dst, struct damos *src)continue ; new_filter =damos_new_filter ( - src_filter->type, src_filter->matching); + src_filter->type, src_filter->matching, + src_filter->allow);if (!new_filter)return -ENOMEM ;damos_commit_filter_arg (new_filter, src_filter);
mm/damon/paddr.c +2 -1
@@ -259,7 +259,8 @@ static unsigned long damon_pa_pageout(struct damon_region *r, struct damos *s, } }if (install_young_filter) { - filter =damos_new_filter (DAMOS_FILTER_TYPE_YOUNG , true); + filter =damos_new_filter ( +DAMOS_FILTER_TYPE_YOUNG , true, false);if (!filter)return 0 ;damos_add_filter (s, filter);
mm/damon/reclaim.c +1 -1
@@ -221,7 +221,7 @@ static int damon_reclaim_apply_parameters(void) }if (skip_anon) { - filter =damos_new_filter (DAMOS_FILTER_TYPE_ANON , true); + filter =damos_new_filter (DAMOS_FILTER_TYPE_ANON , true, false);if (!filter) goto out;damos_add_filter (scheme, filter);
mm/damon/sysfs-schemes.c +1 -1
@@ -1901,7 +1901,7 @@ static int damon_sysfs_add_scheme_filters(struct damos *scheme, sysfs_filters->filters_arr[i];struct damos_filter *filter =damos_new_filter (sysfs_filter->type, - sysfs_filter->matching); + sysfs_filter->matching, false);int err;if (!filter)
mm/damon/tests/core-kunit.h +2 -2
@@ -411,7 +411,7 @@ static void damos_test_new_filter(struct kunit *test) {struct damos_filter *filter; - filter =damos_new_filter (DAMOS_FILTER_TYPE_ANON , true); + filter =damos_new_filter (DAMOS_FILTER_TYPE_ANON , true, false);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);
@@ -425,7 +425,7 @@ static void damos_test_filter_out(struct kunit *test)struct damon_region *r, *r2;struct damos_filter *f; - f =damos_new_filter (DAMOS_FILTER_TYPE_ADDR , true); + f =damos_new_filter (DAMOS_FILTER_TYPE_ADDR , true, false); f->addr_range = (struct damon_addr_range ){ .start =DAMON_MIN_REGION *2 , .end =DAMON_MIN_REGION *6 };
Signature · 1 line
2.39.5
SeongJae Park
maintainerPATCH v2 6/10 mm/damon/sysfs-schemes: add a file for setting damos_filter->allow
In reply to SeongJae ParkOnly kernel-space DAMON API users can use inclusive DAMOS filters. Add a sysfs file named 'allow' under DAMOS filter directory of DAMON sysfs interface, to let the user-space users use inclusive DAMOS filters.
--- mm/damon/sysfs-schemes.c | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-)
mm/damon/sysfs-schemes.c +31 -1
@@ -313,6 +313,7 @@ struct damon_sysfs_scheme_filter {struct kobject kobj;enum damos_filter_type type;bool matching; +bool allow;char *memcg_path;struct damon_addr_range addr_range;int target_idx;
@@ -385,6 +386,30 @@ static ssize_t matching_store(struct kobject *kobj,return count; } +static ssize_t allow_show (struct kobject *kobj, +struct kobj_attribute *attr,char *buf) +{ +struct damon_sysfs_scheme_filter *filter =container_of (kobj, + struct damon_sysfs_scheme_filter, kobj); + +return sysfs_emit (buf,"%c\n" , filter->allow ?'Y' :'N' ); +} + +static ssize_t allow_store (struct kobject *kobj, +struct kobj_attribute *attr,const char *buf,size_t count) +{ +struct damon_sysfs_scheme_filter *filter =container_of (kobj, + struct damon_sysfs_scheme_filter, kobj); +bool allow; +int err =kstrtobool (buf, &allow); + +if (err) +return err; + + filter->allow = allow; +return count; +} +static ssize_t memcg_path_show (struct kobject *kobj,struct kobj_attribute *attr,char *buf) {
@@ -482,6 +507,9 @@ static struct kobj_attribute damon_sysfs_scheme_filter_type_attr =static struct kobj_attribute damon_sysfs_scheme_filter_matching_attr =__ATTR_RW_MODE (matching,0600 ); +static struct kobj_attribute damon_sysfs_scheme_filter_allow_attr = +__ATTR_RW_MODE (allow,0600 ); +static struct kobj_attribute damon_sysfs_scheme_filter_memcg_path_attr =__ATTR_RW_MODE (memcg_path,0600 );
@@ -497,6 +525,7 @@ static struct kobj_attribute damon_sysfs_scheme_filter_damon_target_idx_attr =static struct attribute *damon_sysfs_scheme_filter_attrs[] = { &damon_sysfs_scheme_filter_type_attr.attr, &damon_sysfs_scheme_filter_matching_attr.attr, + &damon_sysfs_scheme_filter_allow_attr.attr, &damon_sysfs_scheme_filter_memcg_path_attr.attr, &damon_sysfs_scheme_filter_addr_start_attr.attr, &damon_sysfs_scheme_filter_addr_end_attr.attr,
@@ -1901,7 +1930,8 @@ static int damon_sysfs_add_scheme_filters(struct damos *scheme, sysfs_filters->filters_arr[i];struct damos_filter *filter =damos_new_filter (sysfs_filter->type, - sysfs_filter->matching, false); + sysfs_filter->matching, + sysfs_filter->allow);int err;if (!filter)
Signature · 1 line
2.39.5
SeongJae Park
maintainerPATCH v2 7/10 Docs/mm/damon/design: document allow/reject DAMOS filter behaviors
In reply to SeongJae ParkUpdate DAMOS filters design document to describe the allow/reject behavior of filters.
--- Documentation/mm/damon/design.rst | 33 +++++++++++++++++++++++++++---- 1 file changed, 29 insertions(+), 4 deletions(-)
Documentation/mm/damon/design.rst +29 -4
@@ -504,9 +504,34 @@ have a list of latency-critical processes. To let users optimize DAMOS schemes with such special knowledge, DAMOS provides a feature called DAMOS filters. The feature allows users to set an arbitrary -number of filters for each scheme. Each filter specifies the type of target -memory, and whether it should exclude the memory of the type (filter-out), or -all except the memory of the type (filter-in). +number of filters for each scheme. Each filter specifies + +- a type of memory (``type``), +- whether it is for the memory of the type or all except the type + (``matching``), and +- whether it is to allow (include) or reject (exclude) applying + the scheme's action to the memory (``allow``). + +When multiple filters are installed, each filter is evaluated in the installed +order. If a part of memory is matched to one of the filter, next filters are +ignored. If the memory passes through the filters evaluation stage because it +is not matched to any of the filters, applying the scheme's action to it is +allowed, same to the behavior when no filter exists. + +For example, let's assume 1) a filter for allowing anonymous pages and 2) +another filter for rejecting young pages are installed in the order. If a page +of a region that eligible to apply the scheme's action is an anonymous page, +the scheme's action will be applied to the page regardless of whether it is +young or not, since it matches with the first allow-filter. If the page is +not anonymous but young, the scheme's action will not be applied, since the +second reject-filter blocks it. If the page is neither anonymous nor young, +the page will pass through the filters evaluation stage since there is no +matching filter, and the action will be applied to the page. + +Note that the action can equally be applied to memory that either explicitly +filter-allowed or filters evaluation stage passed. It means that installing +allow-filters at the end of the list makes no practical change but only +filters-checking overhead. For efficient handling of filters, some types of filters are handled by the core layer, while others are handled by operations set. In the latter case,
@@ -516,7 +541,7 @@ filter are not counted as the scheme has tried to the region. In contrast, if a memory regions is filtered by an operations set layer-handled filter, it is counted as the scheme has tried. This difference affects the statistics. -Below types of filters are currently supported. +Below ``type`` of filters are currently supported. - anonymous page - Applied to pages that containing data that not stored in files.
Signature · 1 line
2.39.5
SeongJae Park
maintainerPATCH v2 8/10 Docs/ABI/damon: document DAMOS filter allow sysfs file
In reply to SeongJae ParkUpdate DAMON ABI document for added DAMOS filter 'allow' file.
--- Documentation/ABI/testing/sysfs-kernel-mm-damon | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-)
Documentation/ABI/testing/sysfs-kernel-mm-damon +9 -4
@@ -355,10 +355,15 @@ Description: If 'target' is written to the 'type' file, writing to or What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/schemes/<S>/filters/<F>/matching Date: Dec 2022 Contact: SeongJae Park <[email protected]> -Description: Writing 'Y' or 'N' to this file sets whether to filter out - pages that do or do not match to the 'type' and 'memcg_path', - respectively. Filter out means the action of the scheme will - not be applied to. +Description: Writing 'Y' or 'N' to this file sets whether the filter is for + the memory of the 'type', or all except the 'type'. + +What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/schemes/<S>/filters/<F>/allow +Date: Jan 2025 +Contact: SeongJae Park <[email protected]> +Description: Writing 'Y' or 'N' to this file sets whether to allow or reject + applying the scheme's action to the memory that satisfies the + 'type' and the 'matching' of the directory. What: /sys/kernel/mm/damon/admin/kdamonds/<K>/contexts/<C>/schemes/<S>/stats/nr_tried Date: Mar 2022
Signature · 1 line
2.39.5
SeongJae Park
maintainerPATCH v2 9/10 Docs/admin-guide/mm/damon/usage: omit DAMOS filter details in favor of design doc
In reply to SeongJae ParkDAMON usage document is describing some details about DAMOS filters, which are also documented on the design doc. Deduplicate the details in favor of the design doc.
--- Documentation/admin-guide/mm/damon/usage.rst | 29 ++++++++++---------- 1 file changed, 14 insertions(+), 15 deletions(-)
Documentation/admin-guide/mm/damon/usage.rst +14 -15
@@ -411,13 +411,17 @@ Each filter directory contains six files, namely ``type``, ``matcing``, file, you can write one of five special keywords: ``anon`` for anonymous pages, ``memcg`` for specific memory cgroup, ``young`` for young pages, ``addr`` for specific address range (an open-ended interval), or ``target`` for specific -DAMON monitoring target filtering. In case of the memory cgroup filtering, you -can specify the memory cgroup of the interest by writing the path of the memory -cgroup from the cgroups mount point to ``memcg_path`` file. In case of the -address range filtering, you can specify the start and end address of the range -to ``addr_start`` and ``addr_end`` files, respectively. For the DAMON -monitoring target filtering, you can specify the index of the target between -the list of the DAMON context's monitoring targets list to ``target_idx`` file. +DAMON monitoring target filtering. Meaning of the types are same to the +description on the :ref:`design doc <damon_design_damos_filters>`. + +In case of the memory cgroup filtering, you can specify the memory cgroup of +the interest by writing the path of the memory cgroup from the cgroups mount +point to ``memcg_path`` file. In case of the address range filtering, you can +specify the start and end address of the range to ``addr_start`` and +``addr_end`` files, respectively. For the DAMON monitoring target filtering, +you can specify the index of the target between the list of the DAMON context's +monitoring targets list to ``target_idx`` file. + You can write ``Y`` or ``N`` to ``matching`` file to filter out pages that does or does not match to the type, respectively. Then, the scheme's action will not be applied to the pages that specified to be filtered out.
@@ -434,14 +438,9 @@ pages of all memory cgroups except ``/having_care_already``.:: echo /having_care_already > 1/memcg_path echo Y > 1/matching -Note that ``anon`` and ``memcg`` filters are currently supported only when -``paddr`` :ref:`implementation <sysfs_context>` is being used. - -Also, memory regions that are filtered out by ``addr`` or ``target`` filters -are not counted as the scheme has tried to those, while regions that filtered -out by other type filters are counted as the scheme has tried to. The -difference is applied to :ref:`stats <damos_stats>` and -:ref:`tried regions <sysfs_schemes_tried_regions>`. +Refer to the :ref:`DAMOS filters design documentation +<damon_design_damos_filters>` for more details including when each of the +filters are supported and differences on stats. .. _sysfs_schemes_stats:
Signature · 1 line
2.39.5
SeongJae Park
maintainerPATCH v2 10/10 Docs/admin-guide/mm/damon/usage: document DAMOS filter 'allow' sysfs file
In reply to SeongJae ParkUpdate DAMON usage document for the newly added 'allow' sysfs file for DAMOS filters.
--- Documentation/admin-guide/mm/damon/usage.rst | 33 +++++++++++--------- 1 file changed, 19 insertions(+), 14 deletions(-)
Documentation/admin-guide/mm/damon/usage.rst +19 -14
@@ -83,7 +83,7 @@ comma (","). │ │ │ │ │ │ │ │ │ 0/target_metric,target_value,current_value │ │ │ │ │ │ │ :ref:`watermarks <sysfs_watermarks>`/metric,interval_us,high,mid,low │ │ │ │ │ │ │ :ref:`filters <sysfs_filters>`/nr_filters - │ │ │ │ │ │ │ │ 0/type,matching,memcg_id + │ │ │ │ │ │ │ │ 0/type,matching,memcg_id,allow │ │ │ │ │ │ │ :ref:`stats <sysfs_schemes_stats>`/nr_tried,sz_tried,nr_applied,sz_applied,sz_ops_filter_passed,qt_exceeds │ │ │ │ │ │ │ :ref:`tried_regions <sysfs_schemes_tried_regions>`/total_bytes │ │ │ │ │ │ │ │ 0/start,end,nr_accesses,age,sz_filter_passed
@@ -406,13 +406,14 @@ number (``N``) to the file creates the number of child directories named ``0`` to ``N-1``. Each directory represents each filter. The filters are evaluated in the numeric order. -Each filter directory contains six files, namely ``type``, ``matcing``, -``memcg_path``, ``addr_start``, ``addr_end``, and ``target_idx``. To ``type`` -file, you can write one of five special keywords: ``anon`` for anonymous pages, -``memcg`` for specific memory cgroup, ``young`` for young pages, ``addr`` for -specific address range (an open-ended interval), or ``target`` for specific -DAMON monitoring target filtering. Meaning of the types are same to the -description on the :ref:`design doc <damon_design_damos_filters>`. +Each filter directory contains seven files, namely ``type``, ``matching``, +``allow``, ``memcg_path``, ``addr_start``, ``addr_end``, and ``target_idx``. +To ``type`` file, you can write one of five special keywords: ``anon`` for +anonymous pages, ``memcg`` for specific memory cgroup, ``young`` for young +pages, ``addr`` for specific address range (an open-ended interval), or +``target`` for specific DAMON monitoring target filtering. Meaning of the +types are same to the description on the :ref:`design doc +<damon_design_damos_filters>`. In case of the memory cgroup filtering, you can specify the memory cgroup of the interest by writing the path of the memory cgroup from the cgroups mount
@@ -422,25 +423,29 @@ specify the start and end address of the range to ``addr_start`` and you can specify the index of the target between the list of the DAMON context's monitoring targets list to ``target_idx`` file. -You can write ``Y`` or ``N`` to ``matching`` file to filter out pages that does -or does not match to the type, respectively. Then, the scheme's action will -not be applied to the pages that specified to be filtered out. +You can write ``Y`` or ``N`` to ``matching`` file to specify whether the filter +is for memory that matches the ``type``. You can write ``Y`` or ``N`` to +``allow`` file to specify if applying the action to the memory that satisfies +the ``type`` and ``matching`` should be allowed or not. For example, below restricts a DAMOS action to be applied to only non-anonymous pages of all memory cgroups except ``/having_care_already``.:: # echo 2 > nr_filters - # # filter out anonymous pages + # # disallow anonymous pages echo anon > 0/type echo Y > 0/matching + echo N > 0/allow # # further filter out all cgroups except one at '/having_care_already' echo memcg > 1/type echo /having_care_already > 1/memcg_path echo Y > 1/matching + echo N > 1/allow Refer to the :ref:`DAMOS filters design documentation -<damon_design_damos_filters>` for more details including when each of the -filters are supported and differences on stats. +<damon_design_damos_filters>` for more details including how multiple filters +of different ``allow`` works, when each of the filters are supported, and +differences on stats. .. _sysfs_schemes_stats:
Signature · 1 line
2.39.5