mm/damon: cleanup and refactoring code
Subsystems (2)
SeongJae Park
maintainerv2 cover mm/damon: cleanup and refactoring code
Changes from v1
(https://lore.kernel.org/damon/[email protected]/):
- Add 10th patch, which splits schemes sysfs directory implementation
This patchset cleans up and refactors a range of DAMON code including the core, DAMON sysfs interface, and DAMON modules, for better readability and convenient future feature implementations.
In detail, this patchset splits unnecessarily long and complex functions in core into smaller functions (patches 1-4). Then, it cleans up the DAMON sysfs interface by using more type-safe code (patch 5) and removing unnecessary function parameters (patch 6). Further, it refactor the code by distributing the code into multiple files (patches 7-10). Last two patches (patches 11 and 12) deduplicates and remove unnecessary header inclusion in DAMON modules (reclaim and lru_sort).
Note that this initially posted as a part of a feature implementation RFC patchset[1], but separated into this patchset as the amount of the change is not small compared to the feature implementation change itself.
[1] https://lore.kernel.org/damon/[email protected]/
SeongJae Park (12):
mm/damon/core: split out DAMOS-charged region skip logic into a new
function
mm/damon/core: split damos application logic into a new function mm/damon/core: split out scheme stat update logic into a new function mm/damon/core: split out scheme quota adjustment logic into a new
function
mm/damon/sysfs: use damon_addr_range for regions' start and end values mm/damon/sysfs: remove parameters of damon_sysfs_region_alloc() mm/damon/sysfs: move sysfs_lock to common module mm/damon/sysfs: move unsigned long range directory to common module mm/damon/sysfs: split out kdamond-independent schemes stats update
logic into a new function
mm/damon/sysfs: split out schemes directory implementation to separate
file
mm/damon/modules: deduplicate init steps for DAMON context setup mm/damon/{reclaim,lru_sort}: remove unnecessarily included headers
mm/damon/Makefile | 6 +- mm/damon/core.c | 262 +++++---- mm/damon/lru_sort.c | 19 +- mm/damon/modules-common.c | 42 ++ mm/damon/modules-common.h | 3 + mm/damon/reclaim.c | 19 +- mm/damon/sysfs-common.c | 107 ++++ mm/damon/sysfs-common.h | 46 ++ mm/damon/sysfs-schemes.c | 1022 ++++++++++++++++++++++++++++++++ mm/damon/sysfs.c | 1152 +------------------------------------ 10 files changed, 1399 insertions(+), 1279 deletions(-) create mode 100644 mm/damon/modules-common.c create mode 100644 mm/damon/sysfs-common.c create mode 100644 mm/damon/sysfs-common.h create mode 100644 mm/damon/sysfs-schemes.c
Signature · 1 line
2.25.1
SeongJae Park
maintainerPATCH v2 1/12 mm/damon/core: split out DAMOS-charged region skip logic into a new function
The DAMOS action applying function, 'damon_do_apply_schemes()', is quite long and not so simple. Split out the already quota-charged region skip code, which is not a small amount of simple code, into a new function with some comments for better readability.
--- mm/damon/core.c | 96 +++++++++++++++++++++++++++++++++---------------- 1 file changed, 65 insertions(+), 31 deletions(-)
mm/damon/core.c +65 -31
@@ -694,6 +694,67 @@ static bool damos_valid_target(struct damon_ctx *c, struct damon_target *t,return c->ops.get_scheme_score (c, t, r, s) >= s->quota.min_score; } +/* +* damos_skip_charged_region() - Check if the given region or starting part of +* it is already charged for the DAMOS quota. +* @t: The target of the region. +* @rp: The pointer to the region. +* @s: The scheme to be applied. +* +* If a quota of a scheme has exceeded in a quota charge window, the scheme's +* action would applied to only a part of the target access pattern fulfilling +* regions. To avoid applying the scheme action to only already applied +* regions, DAMON skips applying the scheme action to the regions that charged +* in the previous charge window. +* +* This function checks if a given region should be skipped or not for the +* reason. If only the starting part of the region has previously charged, +* this function splits the region into two so that the second one covers the +* area that not charged in the previous charge widnow and saves the second +* region in *rp and returns false, so that the caller can apply DAMON action +* to the second one. +* +* Return: true if the region should be entirely skipped, false otherwise. +*/ +static bool damos_skip_charged_region (struct damon_target *t, +struct damon_region **rp,struct damos *s) +{ +struct damon_region *r = *rp; +struct damos_quota *quota = &s->quota; +unsigned long sz_to_skip; + +/* Skip previously charged regions */ +if (quota->charge_target_from) { +if (t != quota->charge_target_from) +return true; +if (r ==damon_last_region (t)) { + quota->charge_target_from =NULL ; + quota->charge_addr_from =0 ; +return true; + } +if (quota->charge_addr_from && + r->ar.end <= quota->charge_addr_from) +return true; + +if (quota->charge_addr_from && r->ar.start < + quota->charge_addr_from) { + sz_to_skip =ALIGN_DOWN (quota->charge_addr_from - + r->ar.start,DAMON_MIN_REGION ); +if (!sz_to_skip) { +if (damon_sz_region (r) <=DAMON_MIN_REGION ) +return true; + sz_to_skip =DAMON_MIN_REGION ; + } +damon_split_region_at (t, r, sz_to_skip); + r =damon_next_region (r); + *rp = r; + } + quota->charge_target_from =NULL ; + quota->charge_addr_from =0 ; + } +return false; +} +static void damon_do_apply_schemes (struct damon_ctx *c,struct damon_target *t,struct damon_region *r)
@@ -702,7 +763,7 @@ static void damon_do_apply_schemes(struct damon_ctx *c,damon_for_each_scheme (s, c) {struct damos_quota *quota = &s->quota; -unsigned long sz =damon_sz_region (r); +unsigned long sz;struct timespec64 begin, end;unsigned long sz_applied =0 ;
@@ -713,41 +774,14 @@ static void damon_do_apply_schemes(struct damon_ctx *c,if (quota->esz && quota->charged_sz >= quota->esz)continue ; -/* Skip previously charged regions */ -if (quota->charge_target_from) { -if (t != quota->charge_target_from) -continue ; -if (r ==damon_last_region (t)) { - quota->charge_target_from =NULL ; - quota->charge_addr_from =0 ; -continue ; - } -if (quota->charge_addr_from && - r->ar.end <= quota->charge_addr_from) -continue ; - -if (quota->charge_addr_from && r->ar.start < - quota->charge_addr_from) { - sz =ALIGN_DOWN (quota->charge_addr_from - - r->ar.start,DAMON_MIN_REGION ); -if (!sz) { -if (damon_sz_region (r) <= -DAMON_MIN_REGION ) -continue ; - sz =DAMON_MIN_REGION ; - } -damon_split_region_at (t, r, sz); - r =damon_next_region (r); - sz =damon_sz_region (r); - } - quota->charge_target_from =NULL ; - quota->charge_addr_from =0 ; - } +if (damos_skip_charged_region (t, &r, s)) +continue ;if (!damos_valid_target (c, t, r, s))continue ;/* Apply the scheme */ + sz =damon_sz_region (r);if (c->ops.apply_scheme) {if (quota->esz && quota->charged_sz + sz > quota->esz) {
Signature · 1 line
2.25.1
SeongJae Park
maintainerPATCH v2 2/12 mm/damon/core: split damos application logic into a new function
In reply to SeongJae ParkThe DAMOS action applying function, 'damon_do_apply_schemes()', is still long and not easy to read. Split out the code for applying a single action to a single region into a new function for better readability.
--- mm/damon/core.c | 73 ++++++++++++++++++++++++++----------------------- 1 file changed, 39 insertions(+), 34 deletions(-)
mm/damon/core.c +39 -34
@@ -755,6 +755,44 @@ static bool damos_skip_charged_region(struct damon_target *t,return false; } +static void damos_apply_scheme (struct damon_ctx *c,struct damon_target *t, +struct damon_region *r,struct damos *s) +{ +struct damos_quota *quota = &s->quota; +unsigned long sz =damon_sz_region (r); +struct timespec64 begin, end; +unsigned long sz_applied =0 ; + +if (c->ops.apply_scheme) { +if (quota->esz && quota->charged_sz + sz > quota->esz) { + sz =ALIGN_DOWN (quota->esz - quota->charged_sz, +DAMON_MIN_REGION ); +if (!sz) + goto update_stat; +damon_split_region_at (t, r, sz); + } +ktime_get_coarse_ts64 (&begin); + sz_applied = c->ops.apply_scheme (c, t, r, s); +ktime_get_coarse_ts64 (&end); + quota->total_charged_ns +=timespec64_to_ns (&end) - +timespec64_to_ns (&begin); + quota->charged_sz += sz; +if (quota->esz && quota->charged_sz >= quota->esz) { + quota->charge_target_from = t; + quota->charge_addr_from = r->ar.end +1 ; + } + } +if (s->action !=DAMOS_STAT ) + r->age =0 ; + +update_stat: + s->stat.nr_tried++; + s->stat.sz_tried += sz; +if (sz_applied) + s->stat.nr_applied++; + s->stat.sz_applied += sz_applied; +} +static void damon_do_apply_schemes (struct damon_ctx *c,struct damon_target *t,struct damon_region *r)
@@ -763,9 +801,6 @@ static void damon_do_apply_schemes(struct damon_ctx *c,damon_for_each_scheme (s, c) {struct damos_quota *quota = &s->quota; -unsigned long sz; -struct timespec64 begin, end; -unsigned long sz_applied =0 ;if (!s->wmarks.activated)continue ;
@@ -780,37 +815,7 @@ static void damon_do_apply_schemes(struct damon_ctx *c,if (!damos_valid_target (c, t, r, s))continue ; -/* Apply the scheme */ - sz =damon_sz_region (r); -if (c->ops.apply_scheme) { -if (quota->esz && - quota->charged_sz + sz > quota->esz) { - sz =ALIGN_DOWN (quota->esz - quota->charged_sz, -DAMON_MIN_REGION ); -if (!sz) - goto update_stat; -damon_split_region_at (t, r, sz); - } -ktime_get_coarse_ts64 (&begin); - sz_applied = c->ops.apply_scheme (c, t, r, s); -ktime_get_coarse_ts64 (&end); - quota->total_charged_ns +=timespec64_to_ns (&end) - -timespec64_to_ns (&begin); - quota->charged_sz += sz; -if (quota->esz && quota->charged_sz >= quota->esz) { - quota->charge_target_from = t; - quota->charge_addr_from = r->ar.end +1 ; - } - } -if (s->action !=DAMOS_STAT ) - r->age =0 ; - -update_stat: - s->stat.nr_tried++; - s->stat.sz_tried += sz; -if (sz_applied) - s->stat.nr_applied++; - s->stat.sz_applied += sz_applied; +damos_apply_scheme (c, t, r, s); } }
Signature · 1 line
2.25.1
SeongJae Park
maintainerPATCH v2 3/12 mm/damon/core: split out scheme stat update logic into a new function
In reply to SeongJae ParkThe function for applying a given DAMON scheme action to a given DAMON region, 'damos_apply_scheme()' is not quite short. Make it better to read by splitting out the stat update logic into a new function.
--- mm/damon/core.c | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-)
mm/damon/core.c +11 -5
@@ -755,6 +755,16 @@ static bool damos_skip_charged_region(struct damon_target *t,return false; } +static void damos_update_stat (struct damos *s, +unsigned long sz_tried,unsigned long sz_applied) +{ + s->stat.nr_tried++; + s->stat.sz_tried += sz_tried; +if (sz_applied) + s->stat.nr_applied++; + s->stat.sz_applied += sz_applied; +} +static void damos_apply_scheme (struct damon_ctx *c,struct damon_target *t,struct damon_region *r,struct damos *s) {
@@ -786,11 +796,7 @@ static void damos_apply_scheme(struct damon_ctx *c, struct damon_target *t, r->age =0 ; update_stat: - s->stat.nr_tried++; - s->stat.sz_tried += sz; -if (sz_applied) - s->stat.nr_applied++; - s->stat.sz_applied += sz_applied; +damos_update_stat (s, sz, sz_applied); } static void damon_do_apply_schemes(struct damon_ctx *c,
Signature · 1 line
2.25.1
SeongJae Park
maintainerPATCH v2 4/12 mm/damon/core: split out scheme quota adjustment logic into a new function
In reply to SeongJae ParkDAMOS quota adjustment logic in 'kdamond_apply_schemes()', has some amount of code, and the logic is not so straightforward. Split it out to a new function for better readability.
--- mm/damon/core.c | 91 ++++++++++++++++++++++++++----------------------- 1 file changed, 48 insertions(+), 43 deletions(-)
mm/damon/core.c +48 -43
@@ -848,59 +848,64 @@ static void damos_set_effective_quota(struct damos_quota *quota) quota->esz = esz; } -static void kdamond_apply_schemes (struct damon_ctx *c) +static void damos_adjust_quota (struct damon_ctx *c,struct damos *s) { +struct damos_quota *quota = &s->quota;struct damon_target *t; -struct damon_region *r, *next_r; -struct damos *s; +struct damon_region *r; +unsigned long cumulated_sz; +unsigned int score, max_score =0 ; -damon_for_each_scheme (s, c) { -struct damos_quota *quota = &s->quota; -unsigned long cumulated_sz; -unsigned int score, max_score =0 ; +if (!quota->ms && !quota->sz) +return ; -if (!s->wmarks.activated) -continue ; +/* New charge window starts */ +if (time_after_eq (jiffies, quota->charged_from + +msecs_to_jiffies (quota->reset_interval))) { +if (quota->esz && quota->charged_sz >= quota->esz) + s->stat.qt_exceeds++; + quota->total_charged_sz += quota->charged_sz; + quota->charged_from = jiffies; + quota->charged_sz =0 ; +damos_set_effective_quota (quota); + } -if (!quota->ms && !quota->sz) -continue ; +if (!c->ops.get_scheme_score) +return ; -/* New charge window starts */ -if (time_after_eq (jiffies, quota->charged_from + -msecs_to_jiffies ( - quota->reset_interval))) { -if (quota->esz && quota->charged_sz >= quota->esz) - s->stat.qt_exceeds++; - quota->total_charged_sz += quota->charged_sz; - quota->charged_from = jiffies; - quota->charged_sz =0 ; -damos_set_effective_quota (quota); +/* Fill up the score histogram */ +memset (quota->histogram,0 ,sizeof (quota->histogram)); +damon_for_each_target (t, c) { +damon_for_each_region (r, t) { +if (!__damos_valid_target (r, s)) +continue ; + score = c->ops.get_scheme_score (c, t, r, s); + quota->histogram[score] +=damon_sz_region (r); +if (score > max_score) + max_score = score; } + } -if (!c->ops.get_scheme_score) -continue ; +/* Set the min score limit */ +for (cumulated_sz =0 , score = max_score; ; score--) { + cumulated_sz += quota->histogram[score]; +if (cumulated_sz >= quota->esz || !score) +break ; + } + quota->min_score = score; +} -/* Fill up the score histogram */ -memset (quota->histogram,0 ,sizeof (quota->histogram)); -damon_for_each_target (t, c) { -damon_for_each_region (r, t) { -if (!__damos_valid_target (r, s)) -continue ; - score = c->ops.get_scheme_score ( - c, t, r, s); - quota->histogram[score] +=damon_sz_region (r); -if (score > max_score) - max_score = score; - } - } +static void kdamond_apply_schemes (struct damon_ctx *c) +{ +struct damon_target *t; +struct damon_region *r, *next_r; +struct damos *s; -/* Set the min score limit */ -for (cumulated_sz =0 , score = max_score; ; score--) { - cumulated_sz += quota->histogram[score]; -if (cumulated_sz >= quota->esz || !score) -break ; - } - quota->min_score = score; +damon_for_each_scheme (s, c) { +if (!s->wmarks.activated) +continue ; + +damos_adjust_quota (c, s); }damon_for_each_target (t, c) {
Signature · 1 line
2.25.1
SeongJae Park
maintainerPATCH v2 5/12 mm/damon/sysfs: use damon_addr_range for regions' start and end values
In reply to SeongJae ParkDAMON has a struct for each address range but DAMON sysfs interface is using the low type (unsigned long) for storing the start and end addresses of regions. Use the dedicated struct for better type safety.
--- mm/damon/sysfs.c | 25 +++++++++++-------------- 1 file changed, 11 insertions(+), 14 deletions(-)
mm/damon/sysfs.c +11 -14
@@ -1062,13 +1062,11 @@ static struct kobj_type damon_sysfs_schemes_ktype = {struct damon_sysfs_region {struct kobject kobj; -unsigned long start; -unsigned long end; +struct damon_addr_range ar; };static struct damon_sysfs_region *damon_sysfs_region_alloc ( -unsigned long start, -unsigned long end) +struct damon_addr_range ar) {struct damon_sysfs_region *region =kmalloc (sizeof (*region),GFP_KERNEL );
@@ -1076,8 +1074,7 @@ static struct damon_sysfs_region *damon_sysfs_region_alloc(if (!region)return NULL ; region->kobj = (struct kobject ){}; - region->start = start; - region->end = end; + region->ar = ar;return region; }
@@ -1087,7 +1084,7 @@ static ssize_t start_show(struct kobject *kobj, struct kobj_attribute *attr,struct damon_sysfs_region *region =container_of (kobj, struct damon_sysfs_region, kobj); -return sysfs_emit (buf,"%lu\n" , region->start); +return sysfs_emit (buf,"%lu\n" , region->ar.start); } static ssize_t start_store(struct kobject *kobj, struct kobj_attribute *attr,
@@ -1095,7 +1092,7 @@ static ssize_t start_store(struct kobject *kobj, struct kobj_attribute *attr, {struct damon_sysfs_region *region =container_of (kobj, struct damon_sysfs_region, kobj); -int err =kstrtoul (buf,0 , ®ion->start); +int err =kstrtoul (buf,0 , ®ion->ar.start);return err ? err : count; }
@@ -1106,7 +1103,7 @@ static ssize_t end_show(struct kobject *kobj, struct kobj_attribute *attr,struct damon_sysfs_region *region =container_of (kobj, struct damon_sysfs_region, kobj); -return sysfs_emit (buf,"%lu\n" , region->end); +return sysfs_emit (buf,"%lu\n" , region->ar.end); } static ssize_t end_store(struct kobject *kobj, struct kobj_attribute *attr,
@@ -1114,7 +1111,7 @@ static ssize_t end_store(struct kobject *kobj, struct kobj_attribute *attr, {struct damon_sysfs_region *region =container_of (kobj, struct damon_sysfs_region, kobj); -int err =kstrtoul (buf,0 , ®ion->end); +int err =kstrtoul (buf,0 , ®ion->ar.end);return err ? err : count; }
@@ -1187,7 +1184,7 @@ static int damon_sysfs_regions_add_dirs(struct damon_sysfs_regions *regions, regions->regions_arr = regions_arr;for (i =0 ; i < nr_regions; i++) { - region =damon_sysfs_region_alloc (0 ,0 ); + region =damon_sysfs_region_alloc ((struct damon_addr_range ){});if (!region) {damon_sysfs_regions_rm_dirs (regions);return -ENOMEM ;
@@ -2147,11 +2144,11 @@ static int damon_sysfs_set_regions(struct damon_target *t,struct damon_sysfs_region *sys_region = sysfs_regions->regions_arr[i]; -if (sys_region->start > sys_region->end) +if (sys_region->ar.start > sys_region->ar.end) goto out; - ranges[i].start = sys_region->start; - ranges[i].end = sys_region->end; + ranges[i].start = sys_region->ar.start; + ranges[i].end = sys_region->ar.end;if (i ==0 )continue ;if (ranges[i -1 ].end > ranges[i].start)
Signature · 1 line
2.25.1
SeongJae Park
maintainerPATCH v2 6/12 mm/damon/sysfs: remove parameters of damon_sysfs_region_alloc()
In reply to SeongJae Park'damon_sysfs_region_alloc()' is always called with zero-filled 'struct damon_addr_range', because the start and end addresses should set by users. Remove unnecessary parameters of the function and simplify the body by using 'kzalloc()'.
--- mm/damon/sysfs.c | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-)
mm/damon/sysfs.c +3 -11
@@ -1065,17 +1065,9 @@ struct damon_sysfs_region {struct damon_addr_range ar; }; -static struct damon_sysfs_region *damon_sysfs_region_alloc ( -struct damon_addr_range ar) +static struct damon_sysfs_region *damon_sysfs_region_alloc (void ) { -struct damon_sysfs_region *region =kmalloc (sizeof (*region), -GFP_KERNEL ); - -if (!region) -return NULL ; - region->kobj = (struct kobject ){}; - region->ar = ar; -return region; +return kzalloc (sizeof (struct damon_sysfs_region ),GFP_KERNEL ); } static ssize_t start_show(struct kobject *kobj, struct kobj_attribute *attr,
@@ -1184,7 +1176,7 @@ static int damon_sysfs_regions_add_dirs(struct damon_sysfs_regions *regions, regions->regions_arr = regions_arr;for (i =0 ; i < nr_regions; i++) { - region =damon_sysfs_region_alloc ((struct damon_addr_range ){}); + region =damon_sysfs_region_alloc ();if (!region) {damon_sysfs_regions_rm_dirs (regions);return -ENOMEM ;
Signature · 1 line
2.25.1
SeongJae Park
maintainerPATCH v2 7/12 mm/damon/sysfs: move sysfs_lock to common module
In reply to SeongJae ParkDAMON sysfs interface is implemented in a single file, sysfs.c, which has about 2,800 lines of code. As the interface is hierarchical and some of the code can be reused by different hierarchies, it would make more sense to split out the implementation into common parts and different parts in multiple files. As the beginning of the work, create files for common code and move the global mutex for directories modifications protection into the new file.
--- mm/damon/Makefile | 2 +- mm/damon/sysfs-common.c | 11 +++++++++++ mm/damon/sysfs-common.h | 11 +++++++++++ mm/damon/sysfs.c | 4 +--- 4 files changed, 24 insertions(+), 4 deletions(-) create mode 100644 mm/damon/sysfs-common.c create mode 100644 mm/damon/sysfs-common.h
mm/damon/Makefile +1 -1
@@ -3,7 +3,7 @@ obj-y := core.o obj-$(CONFIG_DAMON_VADDR) += ops-common.o vaddr.o obj-$(CONFIG_DAMON_PADDR) += ops-common.o paddr.o -obj-$(CONFIG_DAMON_SYSFS) += sysfs.o +obj-$(CONFIG_DAMON_SYSFS) += sysfs-common.o sysfs.o obj-$(CONFIG_DAMON_DBGFS) += dbgfs.o obj-$(CONFIG_DAMON_RECLAIM) += reclaim.o obj-$(CONFIG_DAMON_LRU_SORT) += lru_sort.o
mm/damon/sysfs-common.c new file +11 -0
@@ -0,0 +1,11 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Common Primitives for DAMON Sysfs Interface +* +* Author: SeongJae Park <[email protected]> +*/ + +#include "sysfs-common.h" + +DEFINE_MUTEX (damon_sysfs_lock); +
mm/damon/sysfs-common.h new file +11 -0
@@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Common Primitives for DAMON Sysfs Interface +* +* Author: SeongJae Park <[email protected]> +*/ + +#include <linux/damon.h> +#include <linux/kobject.h> + +extern struct mutex damon_sysfs_lock;
mm/damon/sysfs.c +1 -3
@@ -5,13 +5,11 @@* Copyright (c) 2022 SeongJae Park <[email protected]> */ -#include <linux/damon.h> -#include <linux/kobject.h> #include <linux/pid.h> #include <linux/sched.h> #include <linux/slab.h> -static DEFINE_MUTEX (damon_sysfs_lock); +#include "sysfs-common.h" /* * unsigned long range directory
Signature · 1 line
2.25.1
SeongJae Park
maintainerPATCH v2 8/12 mm/damon/sysfs: move unsigned long range directory to common module
In reply to SeongJae ParkThe implementation of unsigned long type range directories can be reused by multiple DAMON sysfs directories including those for DAMON-based Operation Schemes and the range of number of monitoring regions. Move the code into the files for DAMON sysfs common logics.
--- mm/damon/sysfs-common.c | 96 ++++++++++++++++++++++++++++++++++++++ mm/damon/sysfs-common.h | 13 ++++++ mm/damon/sysfs.c | 100 ---------------------------------------- 3 files changed, 109 insertions(+), 100 deletions(-)
mm/damon/sysfs-common.c +96 -0
@@ -5,7 +5,103 @@* Author: SeongJae Park <[email protected]> */ +#include <linux/slab.h> +#include "sysfs-common.h" DEFINE_MUTEX (damon_sysfs_lock); +/* +* unsigned long range directory +*/ + +struct damon_sysfs_ul_range *damon_sysfs_ul_range_alloc ( +unsigned long min, +unsigned long max) +{ +struct damon_sysfs_ul_range *range =kmalloc (sizeof (*range), +GFP_KERNEL ); + +if (!range) +return NULL ; + range->kobj = (struct kobject ){}; + range->min = min; + range->max = max; + +return range; +} + +static ssize_t min_show (struct kobject *kobj,struct kobj_attribute *attr, +char *buf) +{ +struct damon_sysfs_ul_range *range =container_of (kobj, + struct damon_sysfs_ul_range, kobj); + +return sysfs_emit (buf,"%lu\n" , range->min); +} + +static ssize_t min_store (struct kobject *kobj,struct kobj_attribute *attr, +const char *buf,size_t count) +{ +struct damon_sysfs_ul_range *range =container_of (kobj, + struct damon_sysfs_ul_range, kobj); +unsigned long min; +int err; + + err =kstrtoul (buf,0 , &min); +if (err) +return err; + + range->min = min; +return count; +} + +static ssize_t max_show (struct kobject *kobj,struct kobj_attribute *attr, +char *buf) +{ +struct damon_sysfs_ul_range *range =container_of (kobj, + struct damon_sysfs_ul_range, kobj); + +return sysfs_emit (buf,"%lu\n" , range->max); +} + +static ssize_t max_store (struct kobject *kobj,struct kobj_attribute *attr, +const char *buf,size_t count) +{ +struct damon_sysfs_ul_range *range =container_of (kobj, + struct damon_sysfs_ul_range, kobj); +unsigned long max; +int err; + + err =kstrtoul (buf,0 , &max); +if (err) +return err; + + range->max = max; +return count; +} + +void damon_sysfs_ul_range_release (struct kobject *kobj) +{ +kfree (container_of(kobj ,struct damon_sysfs_ul_range ,kobj )); +} + +static struct kobj_attribute damon_sysfs_ul_range_min_attr = +__ATTR_RW_MODE (min,0600 ); + +static struct kobj_attribute damon_sysfs_ul_range_max_attr = +__ATTR_RW_MODE (max,0600 ); + +static struct attribute *damon_sysfs_ul_range_attrs[] = { + &damon_sysfs_ul_range_min_attr.attr, + &damon_sysfs_ul_range_max_attr.attr, +NULL , +}; +ATTRIBUTE_GROUPS (damon_sysfs_ul_range); + +struct kobj_type damon_sysfs_ul_range_ktype = { + .release = damon_sysfs_ul_range_release, + .sysfs_ops = &kobj_sysfs_ops, + .default_groups = damon_sysfs_ul_range_groups, +}; +
mm/damon/sysfs-common.h +13 -0
@@ -9,3 +9,16 @@#include <linux/kobject.h> extern struct mutex damon_sysfs_lock; + +struct damon_sysfs_ul_range { +struct kobject kobj; +unsigned long min; +unsigned long max; +}; + +struct damon_sysfs_ul_range *damon_sysfs_ul_range_alloc ( +unsigned long min, +unsigned long max); +void damon_sysfs_ul_range_release (struct kobject *kobj); + +extern struct kobj_type damon_sysfs_ul_range_ktype;
mm/damon/sysfs.c +0 -100
106 lines not on this page · raw message
Signature · 1 line
2.25.1
SeongJae Park
maintainerPATCH v2 9/12 mm/damon/sysfs: split out kdamond-independent schemes stats update logic into a new function
In reply to SeongJae Park'damon_sysfs_schemes_update_stats()' is coupled with both damon_sysfs_kdamond and damon_sysfs_schemes. It's a wide range of types dependency. It makes splitting the logics a little bit distracting. Split the function so that each function is coupled with smaller range of types.
--- mm/damon/sysfs.c | 35 +++++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 14 deletions(-)
mm/damon/sysfs.c +21 -14
@@ -2204,6 +2204,25 @@ static void damon_sysfs_before_terminate(struct damon_ctx *ctx)mutex_unlock (&ctx->kdamond_lock); } +static void damon_sysfs_schemes_update_stats ( +struct damon_sysfs_schemes *sysfs_schemes, +struct damon_ctx *ctx) +{ +struct damos *scheme; +int schemes_idx =0 ; + +damon_for_each_scheme (scheme, ctx) { +struct damon_sysfs_stats *sysfs_stats; + + sysfs_stats = sysfs_schemes->schemes_arr[schemes_idx++]->stats; + sysfs_stats->nr_tried = scheme->stat.nr_tried; + sysfs_stats->sz_tried = scheme->stat.sz_tried; + sysfs_stats->nr_applied = scheme->stat.nr_applied; + sysfs_stats->sz_applied = scheme->stat.sz_applied; + sysfs_stats->qt_exceeds = scheme->stat.qt_exceeds; + } +} +/* * damon_sysfs_upd_schemes_stats() - Update schemes stats sysfs files. * @kdamond: The kobject wrapper that associated to the kdamond thread.
@@ -2216,23 +2235,11 @@ static void damon_sysfs_before_terminate(struct damon_ctx *ctx)static int damon_sysfs_upd_schemes_stats (struct damon_sysfs_kdamond *kdamond) {struct damon_ctx *ctx = kdamond->damon_ctx; -struct damon_sysfs_schemes *sysfs_schemes; -struct damos *scheme; -int schemes_idx =0 ;if (!ctx)return -EINVAL ; - sysfs_schemes = kdamond->contexts->contexts_arr[0 ]->schemes; -damon_for_each_scheme (scheme, ctx) { -struct damon_sysfs_stats *sysfs_stats; - - sysfs_stats = sysfs_schemes->schemes_arr[schemes_idx++]->stats; - sysfs_stats->nr_tried = scheme->stat.nr_tried; - sysfs_stats->sz_tried = scheme->stat.sz_tried; - sysfs_stats->nr_applied = scheme->stat.nr_applied; - sysfs_stats->sz_applied = scheme->stat.sz_applied; - sysfs_stats->qt_exceeds = scheme->stat.qt_exceeds; - } +damon_sysfs_schemes_update_stats ( + kdamond->contexts->contexts_arr[0 ]->schemes, ctx);return 0 ; }
Signature · 1 line
2.25.1
SeongJae Park
maintainerPATCH v2 10/12 mm/damon/sysfs: split out schemes directory implementation to separate file
In reply to SeongJae ParkDAMON sysfs interface for 'schemes' directory is implemented using about one thousand lines of code. It has no strong dependency with other parts of its file, so split it out to another file for better code management.
--- mm/damon/Makefile | 2 +- mm/damon/sysfs-common.h | 22 + mm/damon/sysfs-schemes.c | 1022 ++++++++++++++++++++++++++++++++++++++ mm/damon/sysfs.c | 1018 ------------------------------------- 4 files changed, 1045 insertions(+), 1019 deletions(-) create mode 100644 mm/damon/sysfs-schemes.c
mm/damon/Makefile +1 -1
@@ -3,7 +3,7 @@ obj-y := core.o obj-$(CONFIG_DAMON_VADDR) += ops-common.o vaddr.o obj-$(CONFIG_DAMON_PADDR) += ops-common.o paddr.o -obj-$(CONFIG_DAMON_SYSFS) += sysfs-common.o sysfs.o +obj-$(CONFIG_DAMON_SYSFS) += sysfs-common.o sysfs-schemes.o sysfs.o obj-$(CONFIG_DAMON_DBGFS) += dbgfs.o obj-$(CONFIG_DAMON_RECLAIM) += reclaim.o obj-$(CONFIG_DAMON_LRU_SORT) += lru_sort.o
mm/damon/sysfs-common.h +22 -0
@@ -22,3 +22,25 @@ struct damon_sysfs_ul_range *damon_sysfs_ul_range_alloc(void damon_sysfs_ul_range_release (struct kobject *kobj);extern struct kobj_type damon_sysfs_ul_range_ktype; + +/* +* schemes directory +*/ + +struct damon_sysfs_schemes { +struct kobject kobj; +struct damon_sysfs_scheme **schemes_arr; +int nr; +}; + +struct damon_sysfs_schemes *damon_sysfs_schemes_alloc (void ); +void damon_sysfs_schemes_rm_dirs (struct damon_sysfs_schemes *schemes); + +extern struct kobj_type damon_sysfs_schemes_ktype; + +int damon_sysfs_set_schemes (struct damon_ctx *ctx, +struct damon_sysfs_schemes *sysfs_schemes); + +void damon_sysfs_schemes_update_stats ( +struct damon_sysfs_schemes *sysfs_schemes, +struct damon_ctx *ctx);
mm/damon/sysfs-schemes.c new file +1022 -0
1,022 lines not on this page · raw message
mm/damon/sysfs.c +0 -1018
1,036 lines not on this page · raw message
Signature · 1 line
2.25.1
SeongJae Park
maintainerPATCH v2 11/12 mm/damon/modules: deduplicate init steps for DAMON context setup
In reply to SeongJae ParkDAMON_RECLAIM and DAMON_LRU_SORT has duplicated code for DAMON context and target initializations. Deduplicate the part by implementing a function for the initialization in 'modules-common.c' and using it.
--- mm/damon/Makefile | 4 ++-- mm/damon/lru_sort.c | 17 +++------------- mm/damon/modules-common.c | 42 +++++++++++++++++++++++++++++++++++++++ mm/damon/modules-common.h | 3 +++ mm/damon/reclaim.c | 17 +++------------- 5 files changed, 53 insertions(+), 30 deletions(-) create mode 100644 mm/damon/modules-common.c
mm/damon/Makefile +2 -2
@@ -5,5 +5,5 @@ obj-$(CONFIG_DAMON_VADDR) += ops-common.o vaddr.o obj-$(CONFIG_DAMON_PADDR) += ops-common.o paddr.o obj-$(CONFIG_DAMON_SYSFS) += sysfs-common.o sysfs-schemes.o sysfs.o obj-$(CONFIG_DAMON_DBGFS) += dbgfs.o -obj-$(CONFIG_DAMON_RECLAIM) += reclaim.o -obj-$(CONFIG_DAMON_LRU_SORT) += lru_sort.o +obj-$(CONFIG_DAMON_RECLAIM) += modules-common.o reclaim.o +obj-$(CONFIG_DAMON_LRU_SORT) += modules-common.o lru_sort.o
mm/damon/lru_sort.c +3 -14
@@ -314,25 +314,14 @@ static int damon_lru_sort_after_wmarks_check(struct damon_ctx *c)static int __init damon_lru_sort_init (void ) { - ctx =damon_new_ctx (); -if (!ctx) -return -ENOMEM ; +int err =damon_modules_new_paddr_ctx_target (&ctx, &target); -if (damon_select_ops (ctx,DAMON_OPS_PADDR )) { -damon_destroy_ctx (ctx); -return -EINVAL ; - } +if (err) +return err; ctx->callback.after_wmarks_check = damon_lru_sort_after_wmarks_check; ctx->callback.after_aggregation = damon_lru_sort_after_aggregation; - target =damon_new_target (); -if (!target) { -damon_destroy_ctx (ctx); -return -ENOMEM ; - } -damon_add_target (ctx, target); -schedule_delayed_work (&damon_lru_sort_timer,0 ); damon_lru_sort_initialized = true;
mm/damon/modules-common.c new file +42 -0
42 lines not on this page · raw message
mm/damon/modules-common.h +3 -0
@@ -44,3 +44,6 @@ 0400); \ module_param_named(nr_##qt_exceed_name, stat.qt_exceeds, ulong, \ 0400); + +int damon_modules_new_paddr_ctx_target (struct damon_ctx **ctxp, +struct damon_target **targetp);
mm/damon/reclaim.c +3 -14
@@ -256,25 +256,14 @@ static int damon_reclaim_after_wmarks_check(struct damon_ctx *c)static int __init damon_reclaim_init (void ) { - ctx =damon_new_ctx (); -if (!ctx) -return -ENOMEM ; +int err =damon_modules_new_paddr_ctx_target (&ctx, &target); -if (damon_select_ops (ctx,DAMON_OPS_PADDR )) { -damon_destroy_ctx (ctx); -return -EINVAL ; - } +if (err) +return err; ctx->callback.after_wmarks_check = damon_reclaim_after_wmarks_check; ctx->callback.after_aggregation = damon_reclaim_after_aggregation; - target =damon_new_target (); -if (!target) { -damon_destroy_ctx (ctx); -return -ENOMEM ; - } -damon_add_target (ctx, target); -schedule_delayed_work (&damon_reclaim_timer,0 ); damon_reclaim_initialized = true;
Signature · 1 line
2.25.1
SeongJae Park
maintainerPATCH v2 12/12 mm/damon/{reclaim,lru_sort}: remove unnecessarily included headers
In reply to SeongJae ParkSome headers that 'reclaim.c' and 'lru_sort.c' are including are unnecessary now owing to previous cleanups and refactorings. Remove those.
--- mm/damon/lru_sort.c | 2 -- mm/damon/reclaim.c | 2 -- 2 files changed, 4 deletions(-)
mm/damon/lru_sort.c +0 -2
@@ -8,9 +8,7 @@#define pr_fmt (fmt) "damon-lru-sort: " fmt#include <linux/damon.h> -#include <linux/ioport.h> #include <linux/module.h> -#include <linux/sched.h> #include <linux/workqueue.h> #include "modules-common.h"
mm/damon/reclaim.c +0 -2
@@ -8,9 +8,7 @@#define pr_fmt (fmt) "damon-reclaim: " fmt#include <linux/damon.h> -#include <linux/ioport.h> #include <linux/module.h> -#include <linux/sched.h> #include <linux/workqueue.h> #include "modules-common.h"
Signature · 1 line
2.25.1
SeongJae Park
maintainerHi Andrew,
Quoted 3 lines · On Wed, 26 Oct 2022 22:59:31 +0000 SeongJae Park <[email protected]> wrote:
Changes from v1
(https://lore.kernel.org/damon/[email protected]/):
- Add 10th patch, which splits schemes sysfs directory implementation
As mentioned above, I mistakenly forgot adding the tenth patch of this series in the previous version. Could you please replace the series with this version?
Please note that the 'synchronous damon_{reclaim,lru_sort} enable/disable' patchset[1] relies on this patchset, so this patchset should be applied before that.
Sorry for your inconvenience.
Also, please note that there are two minor DAMON documentation fixes[2] that not yet picked in mm-unstable.
[1] https://lore.kernel.org/damon/[email protected]/
[2] https://lore.kernel.org/damon/[email protected]/
Thanks,
SJ
[...]