1 // SPDX-License-Identifier: GPL-2.0
3 * DAMON sysfs Interface
5 * Copyright (c) 2022 SeongJae Park <sj@kernel.org>
8 #include <linux/slab.h>
10 #include "sysfs-common.h"
13 * scheme region directory
16 struct damon_sysfs_scheme_region {
18 struct damon_addr_range ar;
19 unsigned int nr_accesses;
21 struct list_head list;
24 static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc(
25 struct damon_region *region)
27 struct damon_sysfs_scheme_region *sysfs_region = kmalloc(
28 sizeof(*sysfs_region), GFP_KERNEL);
32 sysfs_region->kobj = (struct kobject){};
33 sysfs_region->ar = region->ar;
34 sysfs_region->nr_accesses = region->nr_accesses_bp / 10000;
35 sysfs_region->age = region->age;
36 INIT_LIST_HEAD(&sysfs_region->list);
40 static ssize_t start_show(struct kobject *kobj, struct kobj_attribute *attr,
43 struct damon_sysfs_scheme_region *region = container_of(kobj,
44 struct damon_sysfs_scheme_region, kobj);
46 return sysfs_emit(buf, "%lu\n", region->ar.start);
49 static ssize_t end_show(struct kobject *kobj, struct kobj_attribute *attr,
52 struct damon_sysfs_scheme_region *region = container_of(kobj,
53 struct damon_sysfs_scheme_region, kobj);
55 return sysfs_emit(buf, "%lu\n", region->ar.end);
58 static ssize_t nr_accesses_show(struct kobject *kobj,
59 struct kobj_attribute *attr, char *buf)
61 struct damon_sysfs_scheme_region *region = container_of(kobj,
62 struct damon_sysfs_scheme_region, kobj);
64 return sysfs_emit(buf, "%u\n", region->nr_accesses);
67 static ssize_t age_show(struct kobject *kobj, struct kobj_attribute *attr,
70 struct damon_sysfs_scheme_region *region = container_of(kobj,
71 struct damon_sysfs_scheme_region, kobj);
73 return sysfs_emit(buf, "%u\n", region->age);
76 static void damon_sysfs_scheme_region_release(struct kobject *kobj)
78 struct damon_sysfs_scheme_region *region = container_of(kobj,
79 struct damon_sysfs_scheme_region, kobj);
81 list_del(®ion->list);
85 static struct kobj_attribute damon_sysfs_scheme_region_start_attr =
86 __ATTR_RO_MODE(start, 0400);
88 static struct kobj_attribute damon_sysfs_scheme_region_end_attr =
89 __ATTR_RO_MODE(end, 0400);
91 static struct kobj_attribute damon_sysfs_scheme_region_nr_accesses_attr =
92 __ATTR_RO_MODE(nr_accesses, 0400);
94 static struct kobj_attribute damon_sysfs_scheme_region_age_attr =
95 __ATTR_RO_MODE(age, 0400);
97 static struct attribute *damon_sysfs_scheme_region_attrs[] = {
98 &damon_sysfs_scheme_region_start_attr.attr,
99 &damon_sysfs_scheme_region_end_attr.attr,
100 &damon_sysfs_scheme_region_nr_accesses_attr.attr,
101 &damon_sysfs_scheme_region_age_attr.attr,
104 ATTRIBUTE_GROUPS(damon_sysfs_scheme_region);
106 static const struct kobj_type damon_sysfs_scheme_region_ktype = {
107 .release = damon_sysfs_scheme_region_release,
108 .sysfs_ops = &kobj_sysfs_ops,
109 .default_groups = damon_sysfs_scheme_region_groups,
113 * scheme regions directory
117 * enum damos_sysfs_regions_upd_status - Represent DAMOS tried regions update
119 * @DAMOS_TRIED_REGIONS_UPD_IDLE: Waiting for next request.
120 * @DAMOS_TRIED_REGIONS_UPD_STARTED: Update started.
121 * @DAMOS_TRIED_REGIONS_UPD_FINISHED: Update finished.
123 * Each DAMON-based operation scheme (&struct damos) has its own apply
124 * interval, and we need to expose the scheme tried regions based on only
125 * single snapshot. For this, we keep the tried regions update status for each
126 * scheme. The status becomes 'idle' at the beginning.
128 * Once the tried regions update request is received, the request handling
129 * start function (damon_sysfs_scheme_update_regions_start()) sets the status
130 * of all schemes as 'idle' again, and register ->before_damos_apply() and
131 * ->after_sampling() callbacks.
133 * Then, the first followup ->before_damos_apply() callback
134 * (damon_sysfs_before_damos_apply()) sets the status 'started'. The first
135 * ->after_sampling() callback (damon_sysfs_after_sampling()) after the call
136 * is called only after the scheme is completely applied
137 * to the given snapshot. Hence the callback knows the situation by showing
138 * 'started' status, and sets the status as 'finished'. Then,
139 * damon_sysfs_before_damos_apply() understands the situation by showing the
140 * 'finished' status and do nothing.
142 * If DAMOS is not applied to any region due to any reasons including the
143 * access pattern, the watermarks, the quotas, and the filters,
144 * ->before_damos_apply() will not be called back. Until the situation is
145 * changed, the update will not be finished. To avoid this,
146 * damon_sysfs_after_sampling() set the status as 'finished' if more than two
147 * apply intervals of the scheme is passed while the state is 'idle'.
149 * Finally, the tried regions request handling finisher function
150 * (damon_sysfs_schemes_update_regions_stop()) unregisters the callbacks.
152 enum damos_sysfs_regions_upd_status {
153 DAMOS_TRIED_REGIONS_UPD_IDLE,
154 DAMOS_TRIED_REGIONS_UPD_STARTED,
155 DAMOS_TRIED_REGIONS_UPD_FINISHED,
158 struct damon_sysfs_scheme_regions {
160 struct list_head regions_list;
162 unsigned long total_bytes;
163 enum damos_sysfs_regions_upd_status upd_status;
164 unsigned long upd_timeout_jiffies;
167 static struct damon_sysfs_scheme_regions *
168 damon_sysfs_scheme_regions_alloc(void)
170 struct damon_sysfs_scheme_regions *regions = kmalloc(sizeof(*regions),
176 regions->kobj = (struct kobject){};
177 INIT_LIST_HEAD(®ions->regions_list);
178 regions->nr_regions = 0;
179 regions->total_bytes = 0;
180 regions->upd_status = DAMOS_TRIED_REGIONS_UPD_IDLE;
184 static ssize_t total_bytes_show(struct kobject *kobj,
185 struct kobj_attribute *attr, char *buf)
187 struct damon_sysfs_scheme_regions *regions = container_of(kobj,
188 struct damon_sysfs_scheme_regions, kobj);
190 return sysfs_emit(buf, "%lu\n", regions->total_bytes);
193 static void damon_sysfs_scheme_regions_rm_dirs(
194 struct damon_sysfs_scheme_regions *regions)
196 struct damon_sysfs_scheme_region *r, *next;
198 list_for_each_entry_safe(r, next, ®ions->regions_list, list) {
199 /* release function deletes it from the list */
200 kobject_put(&r->kobj);
201 regions->nr_regions--;
205 static void damon_sysfs_scheme_regions_release(struct kobject *kobj)
207 kfree(container_of(kobj, struct damon_sysfs_scheme_regions, kobj));
210 static struct kobj_attribute damon_sysfs_scheme_regions_total_bytes_attr =
211 __ATTR_RO_MODE(total_bytes, 0400);
213 static struct attribute *damon_sysfs_scheme_regions_attrs[] = {
214 &damon_sysfs_scheme_regions_total_bytes_attr.attr,
217 ATTRIBUTE_GROUPS(damon_sysfs_scheme_regions);
219 static const struct kobj_type damon_sysfs_scheme_regions_ktype = {
220 .release = damon_sysfs_scheme_regions_release,
221 .sysfs_ops = &kobj_sysfs_ops,
222 .default_groups = damon_sysfs_scheme_regions_groups,
226 * schemes/stats directory
229 struct damon_sysfs_stats {
231 unsigned long nr_tried;
232 unsigned long sz_tried;
233 unsigned long nr_applied;
234 unsigned long sz_applied;
235 unsigned long qt_exceeds;
238 static struct damon_sysfs_stats *damon_sysfs_stats_alloc(void)
240 return kzalloc(sizeof(struct damon_sysfs_stats), GFP_KERNEL);
243 static ssize_t nr_tried_show(struct kobject *kobj, struct kobj_attribute *attr,
246 struct damon_sysfs_stats *stats = container_of(kobj,
247 struct damon_sysfs_stats, kobj);
249 return sysfs_emit(buf, "%lu\n", stats->nr_tried);
252 static ssize_t sz_tried_show(struct kobject *kobj, struct kobj_attribute *attr,
255 struct damon_sysfs_stats *stats = container_of(kobj,
256 struct damon_sysfs_stats, kobj);
258 return sysfs_emit(buf, "%lu\n", stats->sz_tried);
261 static ssize_t nr_applied_show(struct kobject *kobj,
262 struct kobj_attribute *attr, char *buf)
264 struct damon_sysfs_stats *stats = container_of(kobj,
265 struct damon_sysfs_stats, kobj);
267 return sysfs_emit(buf, "%lu\n", stats->nr_applied);
270 static ssize_t sz_applied_show(struct kobject *kobj,
271 struct kobj_attribute *attr, char *buf)
273 struct damon_sysfs_stats *stats = container_of(kobj,
274 struct damon_sysfs_stats, kobj);
276 return sysfs_emit(buf, "%lu\n", stats->sz_applied);
279 static ssize_t qt_exceeds_show(struct kobject *kobj,
280 struct kobj_attribute *attr, char *buf)
282 struct damon_sysfs_stats *stats = container_of(kobj,
283 struct damon_sysfs_stats, kobj);
285 return sysfs_emit(buf, "%lu\n", stats->qt_exceeds);
288 static void damon_sysfs_stats_release(struct kobject *kobj)
290 kfree(container_of(kobj, struct damon_sysfs_stats, kobj));
293 static struct kobj_attribute damon_sysfs_stats_nr_tried_attr =
294 __ATTR_RO_MODE(nr_tried, 0400);
296 static struct kobj_attribute damon_sysfs_stats_sz_tried_attr =
297 __ATTR_RO_MODE(sz_tried, 0400);
299 static struct kobj_attribute damon_sysfs_stats_nr_applied_attr =
300 __ATTR_RO_MODE(nr_applied, 0400);
302 static struct kobj_attribute damon_sysfs_stats_sz_applied_attr =
303 __ATTR_RO_MODE(sz_applied, 0400);
305 static struct kobj_attribute damon_sysfs_stats_qt_exceeds_attr =
306 __ATTR_RO_MODE(qt_exceeds, 0400);
308 static struct attribute *damon_sysfs_stats_attrs[] = {
309 &damon_sysfs_stats_nr_tried_attr.attr,
310 &damon_sysfs_stats_sz_tried_attr.attr,
311 &damon_sysfs_stats_nr_applied_attr.attr,
312 &damon_sysfs_stats_sz_applied_attr.attr,
313 &damon_sysfs_stats_qt_exceeds_attr.attr,
316 ATTRIBUTE_GROUPS(damon_sysfs_stats);
318 static const struct kobj_type damon_sysfs_stats_ktype = {
319 .release = damon_sysfs_stats_release,
320 .sysfs_ops = &kobj_sysfs_ops,
321 .default_groups = damon_sysfs_stats_groups,
328 struct damon_sysfs_scheme_filter {
330 enum damos_filter_type type;
333 struct damon_addr_range addr_range;
337 static struct damon_sysfs_scheme_filter *damon_sysfs_scheme_filter_alloc(void)
339 return kzalloc(sizeof(struct damon_sysfs_scheme_filter), GFP_KERNEL);
342 /* Should match with enum damos_filter_type */
343 static const char * const damon_sysfs_scheme_filter_type_strs[] = {
350 static ssize_t type_show(struct kobject *kobj,
351 struct kobj_attribute *attr, char *buf)
353 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
354 struct damon_sysfs_scheme_filter, kobj);
356 return sysfs_emit(buf, "%s\n",
357 damon_sysfs_scheme_filter_type_strs[filter->type]);
360 static ssize_t type_store(struct kobject *kobj,
361 struct kobj_attribute *attr, const char *buf, size_t count)
363 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
364 struct damon_sysfs_scheme_filter, kobj);
365 enum damos_filter_type type;
366 ssize_t ret = -EINVAL;
368 for (type = 0; type < NR_DAMOS_FILTER_TYPES; type++) {
369 if (sysfs_streq(buf, damon_sysfs_scheme_filter_type_strs[
379 static ssize_t matching_show(struct kobject *kobj,
380 struct kobj_attribute *attr, char *buf)
382 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
383 struct damon_sysfs_scheme_filter, kobj);
385 return sysfs_emit(buf, "%c\n", filter->matching ? 'Y' : 'N');
388 static ssize_t matching_store(struct kobject *kobj,
389 struct kobj_attribute *attr, const char *buf, size_t count)
391 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
392 struct damon_sysfs_scheme_filter, kobj);
394 int err = kstrtobool(buf, &matching);
399 filter->matching = matching;
403 static ssize_t memcg_path_show(struct kobject *kobj,
404 struct kobj_attribute *attr, char *buf)
406 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
407 struct damon_sysfs_scheme_filter, kobj);
409 return sysfs_emit(buf, "%s\n",
410 filter->memcg_path ? filter->memcg_path : "");
413 static ssize_t memcg_path_store(struct kobject *kobj,
414 struct kobj_attribute *attr, const char *buf, size_t count)
416 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
417 struct damon_sysfs_scheme_filter, kobj);
418 char *path = kmalloc(sizeof(*path) * (count + 1), GFP_KERNEL);
423 strscpy(path, buf, count + 1);
424 filter->memcg_path = path;
428 static ssize_t addr_start_show(struct kobject *kobj,
429 struct kobj_attribute *attr, char *buf)
431 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
432 struct damon_sysfs_scheme_filter, kobj);
434 return sysfs_emit(buf, "%lu\n", filter->addr_range.start);
437 static ssize_t addr_start_store(struct kobject *kobj,
438 struct kobj_attribute *attr, const char *buf, size_t count)
440 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
441 struct damon_sysfs_scheme_filter, kobj);
442 int err = kstrtoul(buf, 0, &filter->addr_range.start);
444 return err ? err : count;
447 static ssize_t addr_end_show(struct kobject *kobj,
448 struct kobj_attribute *attr, char *buf)
450 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
451 struct damon_sysfs_scheme_filter, kobj);
453 return sysfs_emit(buf, "%lu\n", filter->addr_range.end);
456 static ssize_t addr_end_store(struct kobject *kobj,
457 struct kobj_attribute *attr, const char *buf, size_t count)
459 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
460 struct damon_sysfs_scheme_filter, kobj);
461 int err = kstrtoul(buf, 0, &filter->addr_range.end);
463 return err ? err : count;
466 static ssize_t damon_target_idx_show(struct kobject *kobj,
467 struct kobj_attribute *attr, char *buf)
469 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
470 struct damon_sysfs_scheme_filter, kobj);
472 return sysfs_emit(buf, "%d\n", filter->target_idx);
475 static ssize_t damon_target_idx_store(struct kobject *kobj,
476 struct kobj_attribute *attr, const char *buf, size_t count)
478 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
479 struct damon_sysfs_scheme_filter, kobj);
480 int err = kstrtoint(buf, 0, &filter->target_idx);
482 return err ? err : count;
485 static void damon_sysfs_scheme_filter_release(struct kobject *kobj)
487 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
488 struct damon_sysfs_scheme_filter, kobj);
490 kfree(filter->memcg_path);
494 static struct kobj_attribute damon_sysfs_scheme_filter_type_attr =
495 __ATTR_RW_MODE(type, 0600);
497 static struct kobj_attribute damon_sysfs_scheme_filter_matching_attr =
498 __ATTR_RW_MODE(matching, 0600);
500 static struct kobj_attribute damon_sysfs_scheme_filter_memcg_path_attr =
501 __ATTR_RW_MODE(memcg_path, 0600);
503 static struct kobj_attribute damon_sysfs_scheme_filter_addr_start_attr =
504 __ATTR_RW_MODE(addr_start, 0600);
506 static struct kobj_attribute damon_sysfs_scheme_filter_addr_end_attr =
507 __ATTR_RW_MODE(addr_end, 0600);
509 static struct kobj_attribute damon_sysfs_scheme_filter_damon_target_idx_attr =
510 __ATTR_RW_MODE(damon_target_idx, 0600);
512 static struct attribute *damon_sysfs_scheme_filter_attrs[] = {
513 &damon_sysfs_scheme_filter_type_attr.attr,
514 &damon_sysfs_scheme_filter_matching_attr.attr,
515 &damon_sysfs_scheme_filter_memcg_path_attr.attr,
516 &damon_sysfs_scheme_filter_addr_start_attr.attr,
517 &damon_sysfs_scheme_filter_addr_end_attr.attr,
518 &damon_sysfs_scheme_filter_damon_target_idx_attr.attr,
521 ATTRIBUTE_GROUPS(damon_sysfs_scheme_filter);
523 static const struct kobj_type damon_sysfs_scheme_filter_ktype = {
524 .release = damon_sysfs_scheme_filter_release,
525 .sysfs_ops = &kobj_sysfs_ops,
526 .default_groups = damon_sysfs_scheme_filter_groups,
533 struct damon_sysfs_scheme_filters {
535 struct damon_sysfs_scheme_filter **filters_arr;
539 static struct damon_sysfs_scheme_filters *
540 damon_sysfs_scheme_filters_alloc(void)
542 return kzalloc(sizeof(struct damon_sysfs_scheme_filters), GFP_KERNEL);
545 static void damon_sysfs_scheme_filters_rm_dirs(
546 struct damon_sysfs_scheme_filters *filters)
548 struct damon_sysfs_scheme_filter **filters_arr = filters->filters_arr;
551 for (i = 0; i < filters->nr; i++)
552 kobject_put(&filters_arr[i]->kobj);
555 filters->filters_arr = NULL;
558 static int damon_sysfs_scheme_filters_add_dirs(
559 struct damon_sysfs_scheme_filters *filters, int nr_filters)
561 struct damon_sysfs_scheme_filter **filters_arr, *filter;
564 damon_sysfs_scheme_filters_rm_dirs(filters);
568 filters_arr = kmalloc_array(nr_filters, sizeof(*filters_arr),
569 GFP_KERNEL | __GFP_NOWARN);
572 filters->filters_arr = filters_arr;
574 for (i = 0; i < nr_filters; i++) {
575 filter = damon_sysfs_scheme_filter_alloc();
577 damon_sysfs_scheme_filters_rm_dirs(filters);
581 err = kobject_init_and_add(&filter->kobj,
582 &damon_sysfs_scheme_filter_ktype,
583 &filters->kobj, "%d", i);
585 kobject_put(&filter->kobj);
586 damon_sysfs_scheme_filters_rm_dirs(filters);
590 filters_arr[i] = filter;
596 static ssize_t nr_filters_show(struct kobject *kobj,
597 struct kobj_attribute *attr, char *buf)
599 struct damon_sysfs_scheme_filters *filters = container_of(kobj,
600 struct damon_sysfs_scheme_filters, kobj);
602 return sysfs_emit(buf, "%d\n", filters->nr);
605 static ssize_t nr_filters_store(struct kobject *kobj,
606 struct kobj_attribute *attr, const char *buf, size_t count)
608 struct damon_sysfs_scheme_filters *filters;
609 int nr, err = kstrtoint(buf, 0, &nr);
616 filters = container_of(kobj, struct damon_sysfs_scheme_filters, kobj);
618 if (!mutex_trylock(&damon_sysfs_lock))
620 err = damon_sysfs_scheme_filters_add_dirs(filters, nr);
621 mutex_unlock(&damon_sysfs_lock);
628 static void damon_sysfs_scheme_filters_release(struct kobject *kobj)
630 kfree(container_of(kobj, struct damon_sysfs_scheme_filters, kobj));
633 static struct kobj_attribute damon_sysfs_scheme_filters_nr_attr =
634 __ATTR_RW_MODE(nr_filters, 0600);
636 static struct attribute *damon_sysfs_scheme_filters_attrs[] = {
637 &damon_sysfs_scheme_filters_nr_attr.attr,
640 ATTRIBUTE_GROUPS(damon_sysfs_scheme_filters);
642 static const struct kobj_type damon_sysfs_scheme_filters_ktype = {
643 .release = damon_sysfs_scheme_filters_release,
644 .sysfs_ops = &kobj_sysfs_ops,
645 .default_groups = damon_sysfs_scheme_filters_groups,
649 * watermarks directory
652 struct damon_sysfs_watermarks {
654 enum damos_wmark_metric metric;
655 unsigned long interval_us;
661 static struct damon_sysfs_watermarks *damon_sysfs_watermarks_alloc(
662 enum damos_wmark_metric metric, unsigned long interval_us,
663 unsigned long high, unsigned long mid, unsigned long low)
665 struct damon_sysfs_watermarks *watermarks = kmalloc(
666 sizeof(*watermarks), GFP_KERNEL);
670 watermarks->kobj = (struct kobject){};
671 watermarks->metric = metric;
672 watermarks->interval_us = interval_us;
673 watermarks->high = high;
674 watermarks->mid = mid;
675 watermarks->low = low;
679 /* Should match with enum damos_wmark_metric */
680 static const char * const damon_sysfs_wmark_metric_strs[] = {
685 static ssize_t metric_show(struct kobject *kobj, struct kobj_attribute *attr,
688 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
689 struct damon_sysfs_watermarks, kobj);
691 return sysfs_emit(buf, "%s\n",
692 damon_sysfs_wmark_metric_strs[watermarks->metric]);
695 static ssize_t metric_store(struct kobject *kobj, struct kobj_attribute *attr,
696 const char *buf, size_t count)
698 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
699 struct damon_sysfs_watermarks, kobj);
700 enum damos_wmark_metric metric;
702 for (metric = 0; metric < NR_DAMOS_WMARK_METRICS; metric++) {
703 if (sysfs_streq(buf, damon_sysfs_wmark_metric_strs[metric])) {
704 watermarks->metric = metric;
711 static ssize_t interval_us_show(struct kobject *kobj,
712 struct kobj_attribute *attr, char *buf)
714 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
715 struct damon_sysfs_watermarks, kobj);
717 return sysfs_emit(buf, "%lu\n", watermarks->interval_us);
720 static ssize_t interval_us_store(struct kobject *kobj,
721 struct kobj_attribute *attr, const char *buf, size_t count)
723 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
724 struct damon_sysfs_watermarks, kobj);
725 int err = kstrtoul(buf, 0, &watermarks->interval_us);
727 return err ? err : count;
730 static ssize_t high_show(struct kobject *kobj,
731 struct kobj_attribute *attr, char *buf)
733 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
734 struct damon_sysfs_watermarks, kobj);
736 return sysfs_emit(buf, "%lu\n", watermarks->high);
739 static ssize_t high_store(struct kobject *kobj,
740 struct kobj_attribute *attr, const char *buf, size_t count)
742 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
743 struct damon_sysfs_watermarks, kobj);
744 int err = kstrtoul(buf, 0, &watermarks->high);
746 return err ? err : count;
749 static ssize_t mid_show(struct kobject *kobj,
750 struct kobj_attribute *attr, char *buf)
752 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
753 struct damon_sysfs_watermarks, kobj);
755 return sysfs_emit(buf, "%lu\n", watermarks->mid);
758 static ssize_t mid_store(struct kobject *kobj,
759 struct kobj_attribute *attr, const char *buf, size_t count)
761 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
762 struct damon_sysfs_watermarks, kobj);
763 int err = kstrtoul(buf, 0, &watermarks->mid);
765 return err ? err : count;
768 static ssize_t low_show(struct kobject *kobj,
769 struct kobj_attribute *attr, char *buf)
771 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
772 struct damon_sysfs_watermarks, kobj);
774 return sysfs_emit(buf, "%lu\n", watermarks->low);
777 static ssize_t low_store(struct kobject *kobj,
778 struct kobj_attribute *attr, const char *buf, size_t count)
780 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
781 struct damon_sysfs_watermarks, kobj);
782 int err = kstrtoul(buf, 0, &watermarks->low);
784 return err ? err : count;
787 static void damon_sysfs_watermarks_release(struct kobject *kobj)
789 kfree(container_of(kobj, struct damon_sysfs_watermarks, kobj));
792 static struct kobj_attribute damon_sysfs_watermarks_metric_attr =
793 __ATTR_RW_MODE(metric, 0600);
795 static struct kobj_attribute damon_sysfs_watermarks_interval_us_attr =
796 __ATTR_RW_MODE(interval_us, 0600);
798 static struct kobj_attribute damon_sysfs_watermarks_high_attr =
799 __ATTR_RW_MODE(high, 0600);
801 static struct kobj_attribute damon_sysfs_watermarks_mid_attr =
802 __ATTR_RW_MODE(mid, 0600);
804 static struct kobj_attribute damon_sysfs_watermarks_low_attr =
805 __ATTR_RW_MODE(low, 0600);
807 static struct attribute *damon_sysfs_watermarks_attrs[] = {
808 &damon_sysfs_watermarks_metric_attr.attr,
809 &damon_sysfs_watermarks_interval_us_attr.attr,
810 &damon_sysfs_watermarks_high_attr.attr,
811 &damon_sysfs_watermarks_mid_attr.attr,
812 &damon_sysfs_watermarks_low_attr.attr,
815 ATTRIBUTE_GROUPS(damon_sysfs_watermarks);
817 static const struct kobj_type damon_sysfs_watermarks_ktype = {
818 .release = damon_sysfs_watermarks_release,
819 .sysfs_ops = &kobj_sysfs_ops,
820 .default_groups = damon_sysfs_watermarks_groups,
824 * scheme/weights directory
827 struct damon_sysfs_weights {
830 unsigned int nr_accesses;
834 static struct damon_sysfs_weights *damon_sysfs_weights_alloc(unsigned int sz,
835 unsigned int nr_accesses, unsigned int age)
837 struct damon_sysfs_weights *weights = kmalloc(sizeof(*weights),
842 weights->kobj = (struct kobject){};
844 weights->nr_accesses = nr_accesses;
849 static ssize_t sz_permil_show(struct kobject *kobj,
850 struct kobj_attribute *attr, char *buf)
852 struct damon_sysfs_weights *weights = container_of(kobj,
853 struct damon_sysfs_weights, kobj);
855 return sysfs_emit(buf, "%u\n", weights->sz);
858 static ssize_t sz_permil_store(struct kobject *kobj,
859 struct kobj_attribute *attr, const char *buf, size_t count)
861 struct damon_sysfs_weights *weights = container_of(kobj,
862 struct damon_sysfs_weights, kobj);
863 int err = kstrtouint(buf, 0, &weights->sz);
865 return err ? err : count;
868 static ssize_t nr_accesses_permil_show(struct kobject *kobj,
869 struct kobj_attribute *attr, char *buf)
871 struct damon_sysfs_weights *weights = container_of(kobj,
872 struct damon_sysfs_weights, kobj);
874 return sysfs_emit(buf, "%u\n", weights->nr_accesses);
877 static ssize_t nr_accesses_permil_store(struct kobject *kobj,
878 struct kobj_attribute *attr, const char *buf, size_t count)
880 struct damon_sysfs_weights *weights = container_of(kobj,
881 struct damon_sysfs_weights, kobj);
882 int err = kstrtouint(buf, 0, &weights->nr_accesses);
884 return err ? err : count;
887 static ssize_t age_permil_show(struct kobject *kobj,
888 struct kobj_attribute *attr, char *buf)
890 struct damon_sysfs_weights *weights = container_of(kobj,
891 struct damon_sysfs_weights, kobj);
893 return sysfs_emit(buf, "%u\n", weights->age);
896 static ssize_t age_permil_store(struct kobject *kobj,
897 struct kobj_attribute *attr, const char *buf, size_t count)
899 struct damon_sysfs_weights *weights = container_of(kobj,
900 struct damon_sysfs_weights, kobj);
901 int err = kstrtouint(buf, 0, &weights->age);
903 return err ? err : count;
906 static void damon_sysfs_weights_release(struct kobject *kobj)
908 kfree(container_of(kobj, struct damon_sysfs_weights, kobj));
911 static struct kobj_attribute damon_sysfs_weights_sz_attr =
912 __ATTR_RW_MODE(sz_permil, 0600);
914 static struct kobj_attribute damon_sysfs_weights_nr_accesses_attr =
915 __ATTR_RW_MODE(nr_accesses_permil, 0600);
917 static struct kobj_attribute damon_sysfs_weights_age_attr =
918 __ATTR_RW_MODE(age_permil, 0600);
920 static struct attribute *damon_sysfs_weights_attrs[] = {
921 &damon_sysfs_weights_sz_attr.attr,
922 &damon_sysfs_weights_nr_accesses_attr.attr,
923 &damon_sysfs_weights_age_attr.attr,
926 ATTRIBUTE_GROUPS(damon_sysfs_weights);
928 static const struct kobj_type damon_sysfs_weights_ktype = {
929 .release = damon_sysfs_weights_release,
930 .sysfs_ops = &kobj_sysfs_ops,
931 .default_groups = damon_sysfs_weights_groups,
938 struct damon_sysfs_quotas {
940 struct damon_sysfs_weights *weights;
943 unsigned long reset_interval_ms;
946 static struct damon_sysfs_quotas *damon_sysfs_quotas_alloc(void)
948 return kzalloc(sizeof(struct damon_sysfs_quotas), GFP_KERNEL);
951 static int damon_sysfs_quotas_add_dirs(struct damon_sysfs_quotas *quotas)
953 struct damon_sysfs_weights *weights;
956 weights = damon_sysfs_weights_alloc(0, 0, 0);
960 err = kobject_init_and_add(&weights->kobj, &damon_sysfs_weights_ktype,
961 "as->kobj, "weights");
963 kobject_put(&weights->kobj);
965 quotas->weights = weights;
969 static void damon_sysfs_quotas_rm_dirs(struct damon_sysfs_quotas *quotas)
971 kobject_put("as->weights->kobj);
974 static ssize_t ms_show(struct kobject *kobj, struct kobj_attribute *attr,
977 struct damon_sysfs_quotas *quotas = container_of(kobj,
978 struct damon_sysfs_quotas, kobj);
980 return sysfs_emit(buf, "%lu\n", quotas->ms);
983 static ssize_t ms_store(struct kobject *kobj, struct kobj_attribute *attr,
984 const char *buf, size_t count)
986 struct damon_sysfs_quotas *quotas = container_of(kobj,
987 struct damon_sysfs_quotas, kobj);
988 int err = kstrtoul(buf, 0, "as->ms);
995 static ssize_t bytes_show(struct kobject *kobj, struct kobj_attribute *attr,
998 struct damon_sysfs_quotas *quotas = container_of(kobj,
999 struct damon_sysfs_quotas, kobj);
1001 return sysfs_emit(buf, "%lu\n", quotas->sz);
1004 static ssize_t bytes_store(struct kobject *kobj,
1005 struct kobj_attribute *attr, const char *buf, size_t count)
1007 struct damon_sysfs_quotas *quotas = container_of(kobj,
1008 struct damon_sysfs_quotas, kobj);
1009 int err = kstrtoul(buf, 0, "as->sz);
1016 static ssize_t reset_interval_ms_show(struct kobject *kobj,
1017 struct kobj_attribute *attr, char *buf)
1019 struct damon_sysfs_quotas *quotas = container_of(kobj,
1020 struct damon_sysfs_quotas, kobj);
1022 return sysfs_emit(buf, "%lu\n", quotas->reset_interval_ms);
1025 static ssize_t reset_interval_ms_store(struct kobject *kobj,
1026 struct kobj_attribute *attr, const char *buf, size_t count)
1028 struct damon_sysfs_quotas *quotas = container_of(kobj,
1029 struct damon_sysfs_quotas, kobj);
1030 int err = kstrtoul(buf, 0, "as->reset_interval_ms);
1037 static void damon_sysfs_quotas_release(struct kobject *kobj)
1039 kfree(container_of(kobj, struct damon_sysfs_quotas, kobj));
1042 static struct kobj_attribute damon_sysfs_quotas_ms_attr =
1043 __ATTR_RW_MODE(ms, 0600);
1045 static struct kobj_attribute damon_sysfs_quotas_sz_attr =
1046 __ATTR_RW_MODE(bytes, 0600);
1048 static struct kobj_attribute damon_sysfs_quotas_reset_interval_ms_attr =
1049 __ATTR_RW_MODE(reset_interval_ms, 0600);
1051 static struct attribute *damon_sysfs_quotas_attrs[] = {
1052 &damon_sysfs_quotas_ms_attr.attr,
1053 &damon_sysfs_quotas_sz_attr.attr,
1054 &damon_sysfs_quotas_reset_interval_ms_attr.attr,
1057 ATTRIBUTE_GROUPS(damon_sysfs_quotas);
1059 static const struct kobj_type damon_sysfs_quotas_ktype = {
1060 .release = damon_sysfs_quotas_release,
1061 .sysfs_ops = &kobj_sysfs_ops,
1062 .default_groups = damon_sysfs_quotas_groups,
1066 * access_pattern directory
1069 struct damon_sysfs_access_pattern {
1070 struct kobject kobj;
1071 struct damon_sysfs_ul_range *sz;
1072 struct damon_sysfs_ul_range *nr_accesses;
1073 struct damon_sysfs_ul_range *age;
1077 struct damon_sysfs_access_pattern *damon_sysfs_access_pattern_alloc(void)
1079 struct damon_sysfs_access_pattern *access_pattern =
1080 kmalloc(sizeof(*access_pattern), GFP_KERNEL);
1082 if (!access_pattern)
1084 access_pattern->kobj = (struct kobject){};
1085 return access_pattern;
1088 static int damon_sysfs_access_pattern_add_range_dir(
1089 struct damon_sysfs_access_pattern *access_pattern,
1090 struct damon_sysfs_ul_range **range_dir_ptr,
1093 struct damon_sysfs_ul_range *range = damon_sysfs_ul_range_alloc(0, 0);
1098 err = kobject_init_and_add(&range->kobj, &damon_sysfs_ul_range_ktype,
1099 &access_pattern->kobj, name);
1101 kobject_put(&range->kobj);
1103 *range_dir_ptr = range;
1107 static int damon_sysfs_access_pattern_add_dirs(
1108 struct damon_sysfs_access_pattern *access_pattern)
1112 err = damon_sysfs_access_pattern_add_range_dir(access_pattern,
1113 &access_pattern->sz, "sz");
1117 err = damon_sysfs_access_pattern_add_range_dir(access_pattern,
1118 &access_pattern->nr_accesses, "nr_accesses");
1120 goto put_nr_accesses_sz_out;
1122 err = damon_sysfs_access_pattern_add_range_dir(access_pattern,
1123 &access_pattern->age, "age");
1125 goto put_age_nr_accesses_sz_out;
1128 put_age_nr_accesses_sz_out:
1129 kobject_put(&access_pattern->age->kobj);
1130 access_pattern->age = NULL;
1131 put_nr_accesses_sz_out:
1132 kobject_put(&access_pattern->nr_accesses->kobj);
1133 access_pattern->nr_accesses = NULL;
1135 kobject_put(&access_pattern->sz->kobj);
1136 access_pattern->sz = NULL;
1140 static void damon_sysfs_access_pattern_rm_dirs(
1141 struct damon_sysfs_access_pattern *access_pattern)
1143 kobject_put(&access_pattern->sz->kobj);
1144 kobject_put(&access_pattern->nr_accesses->kobj);
1145 kobject_put(&access_pattern->age->kobj);
1148 static void damon_sysfs_access_pattern_release(struct kobject *kobj)
1150 kfree(container_of(kobj, struct damon_sysfs_access_pattern, kobj));
1153 static struct attribute *damon_sysfs_access_pattern_attrs[] = {
1156 ATTRIBUTE_GROUPS(damon_sysfs_access_pattern);
1158 static const struct kobj_type damon_sysfs_access_pattern_ktype = {
1159 .release = damon_sysfs_access_pattern_release,
1160 .sysfs_ops = &kobj_sysfs_ops,
1161 .default_groups = damon_sysfs_access_pattern_groups,
1168 struct damon_sysfs_scheme {
1169 struct kobject kobj;
1170 enum damos_action action;
1171 struct damon_sysfs_access_pattern *access_pattern;
1172 unsigned long apply_interval_us;
1173 struct damon_sysfs_quotas *quotas;
1174 struct damon_sysfs_watermarks *watermarks;
1175 struct damon_sysfs_scheme_filters *filters;
1176 struct damon_sysfs_stats *stats;
1177 struct damon_sysfs_scheme_regions *tried_regions;
1180 /* This should match with enum damos_action */
1181 static const char * const damon_sysfs_damos_action_strs[] = {
1192 static struct damon_sysfs_scheme *damon_sysfs_scheme_alloc(
1193 enum damos_action action, unsigned long apply_interval_us)
1195 struct damon_sysfs_scheme *scheme = kmalloc(sizeof(*scheme),
1200 scheme->kobj = (struct kobject){};
1201 scheme->action = action;
1202 scheme->apply_interval_us = apply_interval_us;
1206 static int damon_sysfs_scheme_set_access_pattern(
1207 struct damon_sysfs_scheme *scheme)
1209 struct damon_sysfs_access_pattern *access_pattern;
1212 access_pattern = damon_sysfs_access_pattern_alloc();
1213 if (!access_pattern)
1215 err = kobject_init_and_add(&access_pattern->kobj,
1216 &damon_sysfs_access_pattern_ktype, &scheme->kobj,
1220 err = damon_sysfs_access_pattern_add_dirs(access_pattern);
1223 scheme->access_pattern = access_pattern;
1227 kobject_put(&access_pattern->kobj);
1231 static int damon_sysfs_scheme_set_quotas(struct damon_sysfs_scheme *scheme)
1233 struct damon_sysfs_quotas *quotas = damon_sysfs_quotas_alloc();
1238 err = kobject_init_and_add("as->kobj, &damon_sysfs_quotas_ktype,
1239 &scheme->kobj, "quotas");
1242 err = damon_sysfs_quotas_add_dirs(quotas);
1245 scheme->quotas = quotas;
1249 kobject_put("as->kobj);
1253 static int damon_sysfs_scheme_set_watermarks(struct damon_sysfs_scheme *scheme)
1255 struct damon_sysfs_watermarks *watermarks =
1256 damon_sysfs_watermarks_alloc(DAMOS_WMARK_NONE, 0, 0, 0, 0);
1261 err = kobject_init_and_add(&watermarks->kobj,
1262 &damon_sysfs_watermarks_ktype, &scheme->kobj,
1265 kobject_put(&watermarks->kobj);
1267 scheme->watermarks = watermarks;
1271 static int damon_sysfs_scheme_set_filters(struct damon_sysfs_scheme *scheme)
1273 struct damon_sysfs_scheme_filters *filters =
1274 damon_sysfs_scheme_filters_alloc();
1279 err = kobject_init_and_add(&filters->kobj,
1280 &damon_sysfs_scheme_filters_ktype, &scheme->kobj,
1283 kobject_put(&filters->kobj);
1285 scheme->filters = filters;
1289 static int damon_sysfs_scheme_set_stats(struct damon_sysfs_scheme *scheme)
1291 struct damon_sysfs_stats *stats = damon_sysfs_stats_alloc();
1296 err = kobject_init_and_add(&stats->kobj, &damon_sysfs_stats_ktype,
1297 &scheme->kobj, "stats");
1299 kobject_put(&stats->kobj);
1301 scheme->stats = stats;
1305 static int damon_sysfs_scheme_set_tried_regions(
1306 struct damon_sysfs_scheme *scheme)
1308 struct damon_sysfs_scheme_regions *tried_regions =
1309 damon_sysfs_scheme_regions_alloc();
1314 err = kobject_init_and_add(&tried_regions->kobj,
1315 &damon_sysfs_scheme_regions_ktype, &scheme->kobj,
1318 kobject_put(&tried_regions->kobj);
1320 scheme->tried_regions = tried_regions;
1324 static int damon_sysfs_scheme_add_dirs(struct damon_sysfs_scheme *scheme)
1328 err = damon_sysfs_scheme_set_access_pattern(scheme);
1331 err = damon_sysfs_scheme_set_quotas(scheme);
1333 goto put_access_pattern_out;
1334 err = damon_sysfs_scheme_set_watermarks(scheme);
1336 goto put_quotas_access_pattern_out;
1337 err = damon_sysfs_scheme_set_filters(scheme);
1339 goto put_watermarks_quotas_access_pattern_out;
1340 err = damon_sysfs_scheme_set_stats(scheme);
1342 goto put_filters_watermarks_quotas_access_pattern_out;
1343 err = damon_sysfs_scheme_set_tried_regions(scheme);
1345 goto put_tried_regions_out;
1348 put_tried_regions_out:
1349 kobject_put(&scheme->tried_regions->kobj);
1350 scheme->tried_regions = NULL;
1351 put_filters_watermarks_quotas_access_pattern_out:
1352 kobject_put(&scheme->filters->kobj);
1353 scheme->filters = NULL;
1354 put_watermarks_quotas_access_pattern_out:
1355 kobject_put(&scheme->watermarks->kobj);
1356 scheme->watermarks = NULL;
1357 put_quotas_access_pattern_out:
1358 kobject_put(&scheme->quotas->kobj);
1359 scheme->quotas = NULL;
1360 put_access_pattern_out:
1361 kobject_put(&scheme->access_pattern->kobj);
1362 scheme->access_pattern = NULL;
1366 static void damon_sysfs_scheme_rm_dirs(struct damon_sysfs_scheme *scheme)
1368 damon_sysfs_access_pattern_rm_dirs(scheme->access_pattern);
1369 kobject_put(&scheme->access_pattern->kobj);
1370 damon_sysfs_quotas_rm_dirs(scheme->quotas);
1371 kobject_put(&scheme->quotas->kobj);
1372 kobject_put(&scheme->watermarks->kobj);
1373 damon_sysfs_scheme_filters_rm_dirs(scheme->filters);
1374 kobject_put(&scheme->filters->kobj);
1375 kobject_put(&scheme->stats->kobj);
1376 damon_sysfs_scheme_regions_rm_dirs(scheme->tried_regions);
1377 kobject_put(&scheme->tried_regions->kobj);
1380 static ssize_t action_show(struct kobject *kobj, struct kobj_attribute *attr,
1383 struct damon_sysfs_scheme *scheme = container_of(kobj,
1384 struct damon_sysfs_scheme, kobj);
1386 return sysfs_emit(buf, "%s\n",
1387 damon_sysfs_damos_action_strs[scheme->action]);
1390 static ssize_t action_store(struct kobject *kobj, struct kobj_attribute *attr,
1391 const char *buf, size_t count)
1393 struct damon_sysfs_scheme *scheme = container_of(kobj,
1394 struct damon_sysfs_scheme, kobj);
1395 enum damos_action action;
1397 for (action = 0; action < NR_DAMOS_ACTIONS; action++) {
1398 if (sysfs_streq(buf, damon_sysfs_damos_action_strs[action])) {
1399 scheme->action = action;
1406 static ssize_t apply_interval_us_show(struct kobject *kobj,
1407 struct kobj_attribute *attr, char *buf)
1409 struct damon_sysfs_scheme *scheme = container_of(kobj,
1410 struct damon_sysfs_scheme, kobj);
1412 return sysfs_emit(buf, "%lu\n", scheme->apply_interval_us);
1415 static ssize_t apply_interval_us_store(struct kobject *kobj,
1416 struct kobj_attribute *attr, const char *buf, size_t count)
1418 struct damon_sysfs_scheme *scheme = container_of(kobj,
1419 struct damon_sysfs_scheme, kobj);
1420 int err = kstrtoul(buf, 0, &scheme->apply_interval_us);
1422 return err ? err : count;
1425 static void damon_sysfs_scheme_release(struct kobject *kobj)
1427 kfree(container_of(kobj, struct damon_sysfs_scheme, kobj));
1430 static struct kobj_attribute damon_sysfs_scheme_action_attr =
1431 __ATTR_RW_MODE(action, 0600);
1433 static struct kobj_attribute damon_sysfs_scheme_apply_interval_us_attr =
1434 __ATTR_RW_MODE(apply_interval_us, 0600);
1436 static struct attribute *damon_sysfs_scheme_attrs[] = {
1437 &damon_sysfs_scheme_action_attr.attr,
1438 &damon_sysfs_scheme_apply_interval_us_attr.attr,
1441 ATTRIBUTE_GROUPS(damon_sysfs_scheme);
1443 static const struct kobj_type damon_sysfs_scheme_ktype = {
1444 .release = damon_sysfs_scheme_release,
1445 .sysfs_ops = &kobj_sysfs_ops,
1446 .default_groups = damon_sysfs_scheme_groups,
1453 struct damon_sysfs_schemes *damon_sysfs_schemes_alloc(void)
1455 return kzalloc(sizeof(struct damon_sysfs_schemes), GFP_KERNEL);
1458 void damon_sysfs_schemes_rm_dirs(struct damon_sysfs_schemes *schemes)
1460 struct damon_sysfs_scheme **schemes_arr = schemes->schemes_arr;
1463 for (i = 0; i < schemes->nr; i++) {
1464 damon_sysfs_scheme_rm_dirs(schemes_arr[i]);
1465 kobject_put(&schemes_arr[i]->kobj);
1469 schemes->schemes_arr = NULL;
1472 static int damon_sysfs_schemes_add_dirs(struct damon_sysfs_schemes *schemes,
1475 struct damon_sysfs_scheme **schemes_arr, *scheme;
1478 damon_sysfs_schemes_rm_dirs(schemes);
1482 schemes_arr = kmalloc_array(nr_schemes, sizeof(*schemes_arr),
1483 GFP_KERNEL | __GFP_NOWARN);
1486 schemes->schemes_arr = schemes_arr;
1488 for (i = 0; i < nr_schemes; i++) {
1490 * apply_interval_us as 0 means same to aggregation interval
1491 * (same to before-apply_interval behavior)
1493 scheme = damon_sysfs_scheme_alloc(DAMOS_STAT, 0);
1495 damon_sysfs_schemes_rm_dirs(schemes);
1499 err = kobject_init_and_add(&scheme->kobj,
1500 &damon_sysfs_scheme_ktype, &schemes->kobj,
1504 err = damon_sysfs_scheme_add_dirs(scheme);
1508 schemes_arr[i] = scheme;
1514 damon_sysfs_schemes_rm_dirs(schemes);
1515 kobject_put(&scheme->kobj);
1519 static ssize_t nr_schemes_show(struct kobject *kobj,
1520 struct kobj_attribute *attr, char *buf)
1522 struct damon_sysfs_schemes *schemes = container_of(kobj,
1523 struct damon_sysfs_schemes, kobj);
1525 return sysfs_emit(buf, "%d\n", schemes->nr);
1528 static ssize_t nr_schemes_store(struct kobject *kobj,
1529 struct kobj_attribute *attr, const char *buf, size_t count)
1531 struct damon_sysfs_schemes *schemes;
1532 int nr, err = kstrtoint(buf, 0, &nr);
1539 schemes = container_of(kobj, struct damon_sysfs_schemes, kobj);
1541 if (!mutex_trylock(&damon_sysfs_lock))
1543 err = damon_sysfs_schemes_add_dirs(schemes, nr);
1544 mutex_unlock(&damon_sysfs_lock);
1550 static void damon_sysfs_schemes_release(struct kobject *kobj)
1552 kfree(container_of(kobj, struct damon_sysfs_schemes, kobj));
1555 static struct kobj_attribute damon_sysfs_schemes_nr_attr =
1556 __ATTR_RW_MODE(nr_schemes, 0600);
1558 static struct attribute *damon_sysfs_schemes_attrs[] = {
1559 &damon_sysfs_schemes_nr_attr.attr,
1562 ATTRIBUTE_GROUPS(damon_sysfs_schemes);
1564 const struct kobj_type damon_sysfs_schemes_ktype = {
1565 .release = damon_sysfs_schemes_release,
1566 .sysfs_ops = &kobj_sysfs_ops,
1567 .default_groups = damon_sysfs_schemes_groups,
1570 static bool damon_sysfs_memcg_path_eq(struct mem_cgroup *memcg,
1571 char *memcg_path_buf, char *path)
1574 cgroup_path(memcg->css.cgroup, memcg_path_buf, PATH_MAX);
1575 if (sysfs_streq(memcg_path_buf, path))
1577 #endif /* CONFIG_MEMCG */
1581 static int damon_sysfs_memcg_path_to_id(char *memcg_path, unsigned short *id)
1583 struct mem_cgroup *memcg;
1590 path = kmalloc(sizeof(*path) * PATH_MAX, GFP_KERNEL);
1594 for (memcg = mem_cgroup_iter(NULL, NULL, NULL); memcg;
1595 memcg = mem_cgroup_iter(NULL, memcg, NULL)) {
1596 /* skip removed memcg */
1597 if (!mem_cgroup_id(memcg))
1599 if (damon_sysfs_memcg_path_eq(memcg, path, memcg_path)) {
1600 *id = mem_cgroup_id(memcg);
1607 return found ? 0 : -EINVAL;
1610 static int damon_sysfs_set_scheme_filters(struct damos *scheme,
1611 struct damon_sysfs_scheme_filters *sysfs_filters)
1614 struct damos_filter *filter, *next;
1616 damos_for_each_filter_safe(filter, next, scheme)
1617 damos_destroy_filter(filter);
1619 for (i = 0; i < sysfs_filters->nr; i++) {
1620 struct damon_sysfs_scheme_filter *sysfs_filter =
1621 sysfs_filters->filters_arr[i];
1622 struct damos_filter *filter =
1623 damos_new_filter(sysfs_filter->type,
1624 sysfs_filter->matching);
1629 if (filter->type == DAMOS_FILTER_TYPE_MEMCG) {
1630 err = damon_sysfs_memcg_path_to_id(
1631 sysfs_filter->memcg_path,
1634 damos_destroy_filter(filter);
1637 } else if (filter->type == DAMOS_FILTER_TYPE_ADDR) {
1638 if (sysfs_filter->addr_range.end <
1639 sysfs_filter->addr_range.start) {
1640 damos_destroy_filter(filter);
1643 filter->addr_range = sysfs_filter->addr_range;
1644 } else if (filter->type == DAMOS_FILTER_TYPE_TARGET) {
1645 filter->target_idx = sysfs_filter->target_idx;
1648 damos_add_filter(scheme, filter);
1653 static struct damos *damon_sysfs_mk_scheme(
1654 struct damon_sysfs_scheme *sysfs_scheme)
1656 struct damon_sysfs_access_pattern *access_pattern =
1657 sysfs_scheme->access_pattern;
1658 struct damon_sysfs_quotas *sysfs_quotas = sysfs_scheme->quotas;
1659 struct damon_sysfs_weights *sysfs_weights = sysfs_quotas->weights;
1660 struct damon_sysfs_watermarks *sysfs_wmarks = sysfs_scheme->watermarks;
1661 struct damon_sysfs_scheme_filters *sysfs_filters =
1662 sysfs_scheme->filters;
1663 struct damos *scheme;
1666 struct damos_access_pattern pattern = {
1667 .min_sz_region = access_pattern->sz->min,
1668 .max_sz_region = access_pattern->sz->max,
1669 .min_nr_accesses = access_pattern->nr_accesses->min,
1670 .max_nr_accesses = access_pattern->nr_accesses->max,
1671 .min_age_region = access_pattern->age->min,
1672 .max_age_region = access_pattern->age->max,
1674 struct damos_quota quota = {
1675 .ms = sysfs_quotas->ms,
1676 .sz = sysfs_quotas->sz,
1677 .reset_interval = sysfs_quotas->reset_interval_ms,
1678 .weight_sz = sysfs_weights->sz,
1679 .weight_nr_accesses = sysfs_weights->nr_accesses,
1680 .weight_age = sysfs_weights->age,
1682 struct damos_watermarks wmarks = {
1683 .metric = sysfs_wmarks->metric,
1684 .interval = sysfs_wmarks->interval_us,
1685 .high = sysfs_wmarks->high,
1686 .mid = sysfs_wmarks->mid,
1687 .low = sysfs_wmarks->low,
1690 scheme = damon_new_scheme(&pattern, sysfs_scheme->action,
1691 sysfs_scheme->apply_interval_us, "a, &wmarks);
1695 err = damon_sysfs_set_scheme_filters(scheme, sysfs_filters);
1697 damon_destroy_scheme(scheme);
1703 static void damon_sysfs_update_scheme(struct damos *scheme,
1704 struct damon_sysfs_scheme *sysfs_scheme)
1706 struct damon_sysfs_access_pattern *access_pattern =
1707 sysfs_scheme->access_pattern;
1708 struct damon_sysfs_quotas *sysfs_quotas = sysfs_scheme->quotas;
1709 struct damon_sysfs_weights *sysfs_weights = sysfs_quotas->weights;
1710 struct damon_sysfs_watermarks *sysfs_wmarks = sysfs_scheme->watermarks;
1713 scheme->pattern.min_sz_region = access_pattern->sz->min;
1714 scheme->pattern.max_sz_region = access_pattern->sz->max;
1715 scheme->pattern.min_nr_accesses = access_pattern->nr_accesses->min;
1716 scheme->pattern.max_nr_accesses = access_pattern->nr_accesses->max;
1717 scheme->pattern.min_age_region = access_pattern->age->min;
1718 scheme->pattern.max_age_region = access_pattern->age->max;
1720 scheme->action = sysfs_scheme->action;
1721 scheme->apply_interval_us = sysfs_scheme->apply_interval_us;
1723 scheme->quota.ms = sysfs_quotas->ms;
1724 scheme->quota.sz = sysfs_quotas->sz;
1725 scheme->quota.reset_interval = sysfs_quotas->reset_interval_ms;
1726 scheme->quota.weight_sz = sysfs_weights->sz;
1727 scheme->quota.weight_nr_accesses = sysfs_weights->nr_accesses;
1728 scheme->quota.weight_age = sysfs_weights->age;
1730 scheme->wmarks.metric = sysfs_wmarks->metric;
1731 scheme->wmarks.interval = sysfs_wmarks->interval_us;
1732 scheme->wmarks.high = sysfs_wmarks->high;
1733 scheme->wmarks.mid = sysfs_wmarks->mid;
1734 scheme->wmarks.low = sysfs_wmarks->low;
1736 err = damon_sysfs_set_scheme_filters(scheme, sysfs_scheme->filters);
1738 damon_destroy_scheme(scheme);
1741 int damon_sysfs_set_schemes(struct damon_ctx *ctx,
1742 struct damon_sysfs_schemes *sysfs_schemes)
1744 struct damos *scheme, *next;
1747 damon_for_each_scheme_safe(scheme, next, ctx) {
1748 if (i < sysfs_schemes->nr)
1749 damon_sysfs_update_scheme(scheme,
1750 sysfs_schemes->schemes_arr[i]);
1752 damon_destroy_scheme(scheme);
1756 for (; i < sysfs_schemes->nr; i++) {
1757 struct damos *scheme, *next;
1759 scheme = damon_sysfs_mk_scheme(sysfs_schemes->schemes_arr[i]);
1761 damon_for_each_scheme_safe(scheme, next, ctx)
1762 damon_destroy_scheme(scheme);
1765 damon_add_scheme(ctx, scheme);
1770 void damon_sysfs_schemes_update_stats(
1771 struct damon_sysfs_schemes *sysfs_schemes,
1772 struct damon_ctx *ctx)
1774 struct damos *scheme;
1775 int schemes_idx = 0;
1777 damon_for_each_scheme(scheme, ctx) {
1778 struct damon_sysfs_stats *sysfs_stats;
1780 /* user could have removed the scheme sysfs dir */
1781 if (schemes_idx >= sysfs_schemes->nr)
1784 sysfs_stats = sysfs_schemes->schemes_arr[schemes_idx++]->stats;
1785 sysfs_stats->nr_tried = scheme->stat.nr_tried;
1786 sysfs_stats->sz_tried = scheme->stat.sz_tried;
1787 sysfs_stats->nr_applied = scheme->stat.nr_applied;
1788 sysfs_stats->sz_applied = scheme->stat.sz_applied;
1789 sysfs_stats->qt_exceeds = scheme->stat.qt_exceeds;
1794 * damon_sysfs_schemes that need to update its schemes regions dir. Protected
1795 * by damon_sysfs_lock
1797 static struct damon_sysfs_schemes *damon_sysfs_schemes_for_damos_callback;
1798 static int damon_sysfs_schemes_region_idx;
1799 static bool damos_regions_upd_total_bytes_only;
1802 * DAMON callback that called before damos apply. While this callback is
1803 * registered, damon_sysfs_lock should be held to ensure the regions
1804 * directories exist.
1806 static int damon_sysfs_before_damos_apply(struct damon_ctx *ctx,
1807 struct damon_target *t, struct damon_region *r,
1810 struct damos *scheme;
1811 struct damon_sysfs_scheme_regions *sysfs_regions;
1812 struct damon_sysfs_scheme_region *region;
1813 struct damon_sysfs_schemes *sysfs_schemes =
1814 damon_sysfs_schemes_for_damos_callback;
1815 int schemes_idx = 0;
1817 damon_for_each_scheme(scheme, ctx) {
1823 /* user could have removed the scheme sysfs dir */
1824 if (schemes_idx >= sysfs_schemes->nr)
1827 sysfs_regions = sysfs_schemes->schemes_arr[schemes_idx]->tried_regions;
1828 if (sysfs_regions->upd_status == DAMOS_TRIED_REGIONS_UPD_FINISHED)
1830 if (sysfs_regions->upd_status == DAMOS_TRIED_REGIONS_UPD_IDLE)
1831 sysfs_regions->upd_status = DAMOS_TRIED_REGIONS_UPD_STARTED;
1832 sysfs_regions->total_bytes += r->ar.end - r->ar.start;
1833 if (damos_regions_upd_total_bytes_only)
1836 region = damon_sysfs_scheme_region_alloc(r);
1839 list_add_tail(®ion->list, &sysfs_regions->regions_list);
1840 sysfs_regions->nr_regions++;
1841 if (kobject_init_and_add(®ion->kobj,
1842 &damon_sysfs_scheme_region_ktype,
1843 &sysfs_regions->kobj, "%d",
1844 damon_sysfs_schemes_region_idx++)) {
1845 kobject_put(®ion->kobj);
1851 * DAMON callback that called after each accesses sampling. While this
1852 * callback is registered, damon_sysfs_lock should be held to ensure the
1853 * regions directories exist.
1855 static int damon_sysfs_after_sampling(struct damon_ctx *ctx)
1857 struct damon_sysfs_schemes *sysfs_schemes =
1858 damon_sysfs_schemes_for_damos_callback;
1859 struct damon_sysfs_scheme_regions *sysfs_regions;
1862 for (i = 0; i < sysfs_schemes->nr; i++) {
1863 sysfs_regions = sysfs_schemes->schemes_arr[i]->tried_regions;
1864 if (sysfs_regions->upd_status ==
1865 DAMOS_TRIED_REGIONS_UPD_STARTED ||
1867 sysfs_regions->upd_timeout_jiffies))
1868 sysfs_regions->upd_status =
1869 DAMOS_TRIED_REGIONS_UPD_FINISHED;
1875 /* Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock */
1876 int damon_sysfs_schemes_clear_regions(
1877 struct damon_sysfs_schemes *sysfs_schemes,
1878 struct damon_ctx *ctx)
1880 struct damos *scheme;
1881 int schemes_idx = 0;
1883 damon_for_each_scheme(scheme, ctx) {
1884 struct damon_sysfs_scheme *sysfs_scheme;
1886 /* user could have removed the scheme sysfs dir */
1887 if (schemes_idx >= sysfs_schemes->nr)
1890 sysfs_scheme = sysfs_schemes->schemes_arr[schemes_idx++];
1891 damon_sysfs_scheme_regions_rm_dirs(
1892 sysfs_scheme->tried_regions);
1893 sysfs_scheme->tried_regions->total_bytes = 0;
1898 static struct damos *damos_sysfs_nth_scheme(int n, struct damon_ctx *ctx)
1900 struct damos *scheme;
1903 damon_for_each_scheme(scheme, ctx) {
1911 static void damos_tried_regions_init_upd_status(
1912 struct damon_sysfs_schemes *sysfs_schemes,
1913 struct damon_ctx *ctx)
1916 struct damos *scheme;
1917 struct damon_sysfs_scheme_regions *sysfs_regions;
1919 for (i = 0; i < sysfs_schemes->nr; i++) {
1920 sysfs_regions = sysfs_schemes->schemes_arr[i]->tried_regions;
1921 scheme = damos_sysfs_nth_scheme(i, ctx);
1923 sysfs_regions->upd_status =
1924 DAMOS_TRIED_REGIONS_UPD_FINISHED;
1927 sysfs_regions->upd_status = DAMOS_TRIED_REGIONS_UPD_IDLE;
1928 sysfs_regions->upd_timeout_jiffies = jiffies +
1929 2 * usecs_to_jiffies(scheme->apply_interval_us ?
1930 scheme->apply_interval_us :
1931 ctx->attrs.sample_interval);
1935 /* Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock */
1936 int damon_sysfs_schemes_update_regions_start(
1937 struct damon_sysfs_schemes *sysfs_schemes,
1938 struct damon_ctx *ctx, bool total_bytes_only)
1940 damon_sysfs_schemes_clear_regions(sysfs_schemes, ctx);
1941 damon_sysfs_schemes_for_damos_callback = sysfs_schemes;
1942 damos_tried_regions_init_upd_status(sysfs_schemes, ctx);
1943 damos_regions_upd_total_bytes_only = total_bytes_only;
1944 ctx->callback.before_damos_apply = damon_sysfs_before_damos_apply;
1945 ctx->callback.after_sampling = damon_sysfs_after_sampling;
1949 bool damos_sysfs_regions_upd_done(void)
1951 struct damon_sysfs_schemes *sysfs_schemes =
1952 damon_sysfs_schemes_for_damos_callback;
1953 struct damon_sysfs_scheme_regions *sysfs_regions;
1956 for (i = 0; i < sysfs_schemes->nr; i++) {
1957 sysfs_regions = sysfs_schemes->schemes_arr[i]->tried_regions;
1958 if (sysfs_regions->upd_status !=
1959 DAMOS_TRIED_REGIONS_UPD_FINISHED)
1966 * Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock. Caller
1967 * should unlock damon_sysfs_lock which held before
1968 * damon_sysfs_schemes_update_regions_start()
1970 int damon_sysfs_schemes_update_regions_stop(struct damon_ctx *ctx)
1972 damon_sysfs_schemes_for_damos_callback = NULL;
1973 ctx->callback.before_damos_apply = NULL;
1974 ctx->callback.after_sampling = NULL;
1975 damon_sysfs_schemes_region_idx = 0;