1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * DAMON sysfs Interface
4 *
5 * Copyright (c) 2022 SeongJae Park <sj@kernel.org>
6 */
7
8 #include <linux/slab.h>
9
10 #include "sysfs-common.h"
11
12 /*
13 * scheme region directory
14 */
15
16 struct damon_sysfs_scheme_region {
17 struct kobject kobj;
18 struct damon_addr_range ar;
19 unsigned int nr_accesses;
20 unsigned int age;
21 struct list_head list;
22 };
23
damon_sysfs_scheme_region_alloc(struct damon_region * region)24 static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc(
25 struct damon_region *region)
26 {
27 struct damon_sysfs_scheme_region *sysfs_region = kmalloc(
28 sizeof(*sysfs_region), GFP_KERNEL);
29
30 if (!sysfs_region)
31 return NULL;
32 sysfs_region->kobj = (struct kobject){};
33 sysfs_region->ar = region->ar;
34 sysfs_region->nr_accesses = region->nr_accesses;
35 sysfs_region->age = region->age;
36 INIT_LIST_HEAD(&sysfs_region->list);
37 return sysfs_region;
38 }
39
start_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)40 static ssize_t start_show(struct kobject *kobj, struct kobj_attribute *attr,
41 char *buf)
42 {
43 struct damon_sysfs_scheme_region *region = container_of(kobj,
44 struct damon_sysfs_scheme_region, kobj);
45
46 return sysfs_emit(buf, "%lu\n", region->ar.start);
47 }
48
end_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)49 static ssize_t end_show(struct kobject *kobj, struct kobj_attribute *attr,
50 char *buf)
51 {
52 struct damon_sysfs_scheme_region *region = container_of(kobj,
53 struct damon_sysfs_scheme_region, kobj);
54
55 return sysfs_emit(buf, "%lu\n", region->ar.end);
56 }
57
nr_accesses_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)58 static ssize_t nr_accesses_show(struct kobject *kobj,
59 struct kobj_attribute *attr, char *buf)
60 {
61 struct damon_sysfs_scheme_region *region = container_of(kobj,
62 struct damon_sysfs_scheme_region, kobj);
63
64 return sysfs_emit(buf, "%u\n", region->nr_accesses);
65 }
66
age_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)67 static ssize_t age_show(struct kobject *kobj, struct kobj_attribute *attr,
68 char *buf)
69 {
70 struct damon_sysfs_scheme_region *region = container_of(kobj,
71 struct damon_sysfs_scheme_region, kobj);
72
73 return sysfs_emit(buf, "%u\n", region->age);
74 }
75
damon_sysfs_scheme_region_release(struct kobject * kobj)76 static void damon_sysfs_scheme_region_release(struct kobject *kobj)
77 {
78 struct damon_sysfs_scheme_region *region = container_of(kobj,
79 struct damon_sysfs_scheme_region, kobj);
80
81 list_del(®ion->list);
82 kfree(region);
83 }
84
85 static struct kobj_attribute damon_sysfs_scheme_region_start_attr =
86 __ATTR_RO_MODE(start, 0400);
87
88 static struct kobj_attribute damon_sysfs_scheme_region_end_attr =
89 __ATTR_RO_MODE(end, 0400);
90
91 static struct kobj_attribute damon_sysfs_scheme_region_nr_accesses_attr =
92 __ATTR_RO_MODE(nr_accesses, 0400);
93
94 static struct kobj_attribute damon_sysfs_scheme_region_age_attr =
95 __ATTR_RO_MODE(age, 0400);
96
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,
102 NULL,
103 };
104 ATTRIBUTE_GROUPS(damon_sysfs_scheme_region);
105
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,
110 };
111
112 /*
113 * scheme regions directory
114 */
115
116 struct damon_sysfs_scheme_regions {
117 struct kobject kobj;
118 struct list_head regions_list;
119 int nr_regions;
120 unsigned long total_bytes;
121 };
122
123 static struct damon_sysfs_scheme_regions *
damon_sysfs_scheme_regions_alloc(void)124 damon_sysfs_scheme_regions_alloc(void)
125 {
126 struct damon_sysfs_scheme_regions *regions = kmalloc(sizeof(*regions),
127 GFP_KERNEL);
128
129 if (!regions)
130 return NULL;
131
132 regions->kobj = (struct kobject){};
133 INIT_LIST_HEAD(®ions->regions_list);
134 regions->nr_regions = 0;
135 regions->total_bytes = 0;
136 return regions;
137 }
138
total_bytes_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)139 static ssize_t total_bytes_show(struct kobject *kobj,
140 struct kobj_attribute *attr, char *buf)
141 {
142 struct damon_sysfs_scheme_regions *regions = container_of(kobj,
143 struct damon_sysfs_scheme_regions, kobj);
144
145 return sysfs_emit(buf, "%lu\n", regions->total_bytes);
146 }
147
damon_sysfs_scheme_regions_rm_dirs(struct damon_sysfs_scheme_regions * regions)148 static void damon_sysfs_scheme_regions_rm_dirs(
149 struct damon_sysfs_scheme_regions *regions)
150 {
151 struct damon_sysfs_scheme_region *r, *next;
152
153 list_for_each_entry_safe(r, next, ®ions->regions_list, list) {
154 /* release function deletes it from the list */
155 kobject_put(&r->kobj);
156 regions->nr_regions--;
157 }
158 }
159
damon_sysfs_scheme_regions_release(struct kobject * kobj)160 static void damon_sysfs_scheme_regions_release(struct kobject *kobj)
161 {
162 kfree(container_of(kobj, struct damon_sysfs_scheme_regions, kobj));
163 }
164
165 static struct kobj_attribute damon_sysfs_scheme_regions_total_bytes_attr =
166 __ATTR_RO_MODE(total_bytes, 0400);
167
168 static struct attribute *damon_sysfs_scheme_regions_attrs[] = {
169 &damon_sysfs_scheme_regions_total_bytes_attr.attr,
170 NULL,
171 };
172 ATTRIBUTE_GROUPS(damon_sysfs_scheme_regions);
173
174 static const struct kobj_type damon_sysfs_scheme_regions_ktype = {
175 .release = damon_sysfs_scheme_regions_release,
176 .sysfs_ops = &kobj_sysfs_ops,
177 .default_groups = damon_sysfs_scheme_regions_groups,
178 };
179
180 /*
181 * schemes/stats directory
182 */
183
184 struct damon_sysfs_stats {
185 struct kobject kobj;
186 unsigned long nr_tried;
187 unsigned long sz_tried;
188 unsigned long nr_applied;
189 unsigned long sz_applied;
190 unsigned long qt_exceeds;
191 };
192
damon_sysfs_stats_alloc(void)193 static struct damon_sysfs_stats *damon_sysfs_stats_alloc(void)
194 {
195 return kzalloc(sizeof(struct damon_sysfs_stats), GFP_KERNEL);
196 }
197
nr_tried_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)198 static ssize_t nr_tried_show(struct kobject *kobj, struct kobj_attribute *attr,
199 char *buf)
200 {
201 struct damon_sysfs_stats *stats = container_of(kobj,
202 struct damon_sysfs_stats, kobj);
203
204 return sysfs_emit(buf, "%lu\n", stats->nr_tried);
205 }
206
sz_tried_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)207 static ssize_t sz_tried_show(struct kobject *kobj, struct kobj_attribute *attr,
208 char *buf)
209 {
210 struct damon_sysfs_stats *stats = container_of(kobj,
211 struct damon_sysfs_stats, kobj);
212
213 return sysfs_emit(buf, "%lu\n", stats->sz_tried);
214 }
215
nr_applied_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)216 static ssize_t nr_applied_show(struct kobject *kobj,
217 struct kobj_attribute *attr, char *buf)
218 {
219 struct damon_sysfs_stats *stats = container_of(kobj,
220 struct damon_sysfs_stats, kobj);
221
222 return sysfs_emit(buf, "%lu\n", stats->nr_applied);
223 }
224
sz_applied_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)225 static ssize_t sz_applied_show(struct kobject *kobj,
226 struct kobj_attribute *attr, char *buf)
227 {
228 struct damon_sysfs_stats *stats = container_of(kobj,
229 struct damon_sysfs_stats, kobj);
230
231 return sysfs_emit(buf, "%lu\n", stats->sz_applied);
232 }
233
qt_exceeds_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)234 static ssize_t qt_exceeds_show(struct kobject *kobj,
235 struct kobj_attribute *attr, char *buf)
236 {
237 struct damon_sysfs_stats *stats = container_of(kobj,
238 struct damon_sysfs_stats, kobj);
239
240 return sysfs_emit(buf, "%lu\n", stats->qt_exceeds);
241 }
242
damon_sysfs_stats_release(struct kobject * kobj)243 static void damon_sysfs_stats_release(struct kobject *kobj)
244 {
245 kfree(container_of(kobj, struct damon_sysfs_stats, kobj));
246 }
247
248 static struct kobj_attribute damon_sysfs_stats_nr_tried_attr =
249 __ATTR_RO_MODE(nr_tried, 0400);
250
251 static struct kobj_attribute damon_sysfs_stats_sz_tried_attr =
252 __ATTR_RO_MODE(sz_tried, 0400);
253
254 static struct kobj_attribute damon_sysfs_stats_nr_applied_attr =
255 __ATTR_RO_MODE(nr_applied, 0400);
256
257 static struct kobj_attribute damon_sysfs_stats_sz_applied_attr =
258 __ATTR_RO_MODE(sz_applied, 0400);
259
260 static struct kobj_attribute damon_sysfs_stats_qt_exceeds_attr =
261 __ATTR_RO_MODE(qt_exceeds, 0400);
262
263 static struct attribute *damon_sysfs_stats_attrs[] = {
264 &damon_sysfs_stats_nr_tried_attr.attr,
265 &damon_sysfs_stats_sz_tried_attr.attr,
266 &damon_sysfs_stats_nr_applied_attr.attr,
267 &damon_sysfs_stats_sz_applied_attr.attr,
268 &damon_sysfs_stats_qt_exceeds_attr.attr,
269 NULL,
270 };
271 ATTRIBUTE_GROUPS(damon_sysfs_stats);
272
273 static const struct kobj_type damon_sysfs_stats_ktype = {
274 .release = damon_sysfs_stats_release,
275 .sysfs_ops = &kobj_sysfs_ops,
276 .default_groups = damon_sysfs_stats_groups,
277 };
278
279 /*
280 * filter directory
281 */
282
283 struct damon_sysfs_scheme_filter {
284 struct kobject kobj;
285 enum damos_filter_type type;
286 bool matching;
287 char *memcg_path;
288 struct damon_addr_range addr_range;
289 int target_idx;
290 };
291
damon_sysfs_scheme_filter_alloc(void)292 static struct damon_sysfs_scheme_filter *damon_sysfs_scheme_filter_alloc(void)
293 {
294 return kzalloc(sizeof(struct damon_sysfs_scheme_filter), GFP_KERNEL);
295 }
296
297 /* Should match with enum damos_filter_type */
298 static const char * const damon_sysfs_scheme_filter_type_strs[] = {
299 "anon",
300 "memcg",
301 "addr",
302 "target",
303 };
304
type_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)305 static ssize_t type_show(struct kobject *kobj,
306 struct kobj_attribute *attr, char *buf)
307 {
308 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
309 struct damon_sysfs_scheme_filter, kobj);
310
311 return sysfs_emit(buf, "%s\n",
312 damon_sysfs_scheme_filter_type_strs[filter->type]);
313 }
314
type_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)315 static ssize_t type_store(struct kobject *kobj,
316 struct kobj_attribute *attr, const char *buf, size_t count)
317 {
318 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
319 struct damon_sysfs_scheme_filter, kobj);
320 enum damos_filter_type type;
321 ssize_t ret = -EINVAL;
322
323 for (type = 0; type < NR_DAMOS_FILTER_TYPES; type++) {
324 if (sysfs_streq(buf, damon_sysfs_scheme_filter_type_strs[
325 type])) {
326 filter->type = type;
327 ret = count;
328 break;
329 }
330 }
331 return ret;
332 }
333
matching_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)334 static ssize_t matching_show(struct kobject *kobj,
335 struct kobj_attribute *attr, char *buf)
336 {
337 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
338 struct damon_sysfs_scheme_filter, kobj);
339
340 return sysfs_emit(buf, "%c\n", filter->matching ? 'Y' : 'N');
341 }
342
matching_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)343 static ssize_t matching_store(struct kobject *kobj,
344 struct kobj_attribute *attr, const char *buf, size_t count)
345 {
346 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
347 struct damon_sysfs_scheme_filter, kobj);
348 bool matching;
349 int err = kstrtobool(buf, &matching);
350
351 if (err)
352 return err;
353
354 filter->matching = matching;
355 return count;
356 }
357
memcg_path_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)358 static ssize_t memcg_path_show(struct kobject *kobj,
359 struct kobj_attribute *attr, char *buf)
360 {
361 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
362 struct damon_sysfs_scheme_filter, kobj);
363
364 return sysfs_emit(buf, "%s\n",
365 filter->memcg_path ? filter->memcg_path : "");
366 }
367
memcg_path_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)368 static ssize_t memcg_path_store(struct kobject *kobj,
369 struct kobj_attribute *attr, const char *buf, size_t count)
370 {
371 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
372 struct damon_sysfs_scheme_filter, kobj);
373 char *path = kmalloc(sizeof(*path) * (count + 1), GFP_KERNEL);
374
375 if (!path)
376 return -ENOMEM;
377
378 strscpy(path, buf, count + 1);
379 kfree(filter->memcg_path);
380 filter->memcg_path = path;
381 return count;
382 }
383
addr_start_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)384 static ssize_t addr_start_show(struct kobject *kobj,
385 struct kobj_attribute *attr, char *buf)
386 {
387 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
388 struct damon_sysfs_scheme_filter, kobj);
389
390 return sysfs_emit(buf, "%lu\n", filter->addr_range.start);
391 }
392
addr_start_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)393 static ssize_t addr_start_store(struct kobject *kobj,
394 struct kobj_attribute *attr, const char *buf, size_t count)
395 {
396 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
397 struct damon_sysfs_scheme_filter, kobj);
398 int err = kstrtoul(buf, 0, &filter->addr_range.start);
399
400 return err ? err : count;
401 }
402
addr_end_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)403 static ssize_t addr_end_show(struct kobject *kobj,
404 struct kobj_attribute *attr, char *buf)
405 {
406 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
407 struct damon_sysfs_scheme_filter, kobj);
408
409 return sysfs_emit(buf, "%lu\n", filter->addr_range.end);
410 }
411
addr_end_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)412 static ssize_t addr_end_store(struct kobject *kobj,
413 struct kobj_attribute *attr, const char *buf, size_t count)
414 {
415 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
416 struct damon_sysfs_scheme_filter, kobj);
417 int err = kstrtoul(buf, 0, &filter->addr_range.end);
418
419 return err ? err : count;
420 }
421
damon_target_idx_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)422 static ssize_t damon_target_idx_show(struct kobject *kobj,
423 struct kobj_attribute *attr, char *buf)
424 {
425 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
426 struct damon_sysfs_scheme_filter, kobj);
427
428 return sysfs_emit(buf, "%d\n", filter->target_idx);
429 }
430
damon_target_idx_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)431 static ssize_t damon_target_idx_store(struct kobject *kobj,
432 struct kobj_attribute *attr, const char *buf, size_t count)
433 {
434 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
435 struct damon_sysfs_scheme_filter, kobj);
436 int err = kstrtoint(buf, 0, &filter->target_idx);
437
438 return err ? err : count;
439 }
440
damon_sysfs_scheme_filter_release(struct kobject * kobj)441 static void damon_sysfs_scheme_filter_release(struct kobject *kobj)
442 {
443 struct damon_sysfs_scheme_filter *filter = container_of(kobj,
444 struct damon_sysfs_scheme_filter, kobj);
445
446 kfree(filter->memcg_path);
447 kfree(filter);
448 }
449
450 static struct kobj_attribute damon_sysfs_scheme_filter_type_attr =
451 __ATTR_RW_MODE(type, 0600);
452
453 static struct kobj_attribute damon_sysfs_scheme_filter_matching_attr =
454 __ATTR_RW_MODE(matching, 0600);
455
456 static struct kobj_attribute damon_sysfs_scheme_filter_memcg_path_attr =
457 __ATTR_RW_MODE(memcg_path, 0600);
458
459 static struct kobj_attribute damon_sysfs_scheme_filter_addr_start_attr =
460 __ATTR_RW_MODE(addr_start, 0600);
461
462 static struct kobj_attribute damon_sysfs_scheme_filter_addr_end_attr =
463 __ATTR_RW_MODE(addr_end, 0600);
464
465 static struct kobj_attribute damon_sysfs_scheme_filter_damon_target_idx_attr =
466 __ATTR_RW_MODE(damon_target_idx, 0600);
467
468 static struct attribute *damon_sysfs_scheme_filter_attrs[] = {
469 &damon_sysfs_scheme_filter_type_attr.attr,
470 &damon_sysfs_scheme_filter_matching_attr.attr,
471 &damon_sysfs_scheme_filter_memcg_path_attr.attr,
472 &damon_sysfs_scheme_filter_addr_start_attr.attr,
473 &damon_sysfs_scheme_filter_addr_end_attr.attr,
474 &damon_sysfs_scheme_filter_damon_target_idx_attr.attr,
475 NULL,
476 };
477 ATTRIBUTE_GROUPS(damon_sysfs_scheme_filter);
478
479 static const struct kobj_type damon_sysfs_scheme_filter_ktype = {
480 .release = damon_sysfs_scheme_filter_release,
481 .sysfs_ops = &kobj_sysfs_ops,
482 .default_groups = damon_sysfs_scheme_filter_groups,
483 };
484
485 /*
486 * filters directory
487 */
488
489 struct damon_sysfs_scheme_filters {
490 struct kobject kobj;
491 struct damon_sysfs_scheme_filter **filters_arr;
492 int nr;
493 };
494
495 static struct damon_sysfs_scheme_filters *
damon_sysfs_scheme_filters_alloc(void)496 damon_sysfs_scheme_filters_alloc(void)
497 {
498 return kzalloc(sizeof(struct damon_sysfs_scheme_filters), GFP_KERNEL);
499 }
500
damon_sysfs_scheme_filters_rm_dirs(struct damon_sysfs_scheme_filters * filters)501 static void damon_sysfs_scheme_filters_rm_dirs(
502 struct damon_sysfs_scheme_filters *filters)
503 {
504 struct damon_sysfs_scheme_filter **filters_arr = filters->filters_arr;
505 int i;
506
507 for (i = 0; i < filters->nr; i++)
508 kobject_put(&filters_arr[i]->kobj);
509 filters->nr = 0;
510 kfree(filters_arr);
511 filters->filters_arr = NULL;
512 }
513
damon_sysfs_scheme_filters_add_dirs(struct damon_sysfs_scheme_filters * filters,int nr_filters)514 static int damon_sysfs_scheme_filters_add_dirs(
515 struct damon_sysfs_scheme_filters *filters, int nr_filters)
516 {
517 struct damon_sysfs_scheme_filter **filters_arr, *filter;
518 int err, i;
519
520 damon_sysfs_scheme_filters_rm_dirs(filters);
521 if (!nr_filters)
522 return 0;
523
524 filters_arr = kmalloc_array(nr_filters, sizeof(*filters_arr),
525 GFP_KERNEL | __GFP_NOWARN);
526 if (!filters_arr)
527 return -ENOMEM;
528 filters->filters_arr = filters_arr;
529
530 for (i = 0; i < nr_filters; i++) {
531 filter = damon_sysfs_scheme_filter_alloc();
532 if (!filter) {
533 damon_sysfs_scheme_filters_rm_dirs(filters);
534 return -ENOMEM;
535 }
536
537 err = kobject_init_and_add(&filter->kobj,
538 &damon_sysfs_scheme_filter_ktype,
539 &filters->kobj, "%d", i);
540 if (err) {
541 kobject_put(&filter->kobj);
542 damon_sysfs_scheme_filters_rm_dirs(filters);
543 return err;
544 }
545
546 filters_arr[i] = filter;
547 filters->nr++;
548 }
549 return 0;
550 }
551
nr_filters_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)552 static ssize_t nr_filters_show(struct kobject *kobj,
553 struct kobj_attribute *attr, char *buf)
554 {
555 struct damon_sysfs_scheme_filters *filters = container_of(kobj,
556 struct damon_sysfs_scheme_filters, kobj);
557
558 return sysfs_emit(buf, "%d\n", filters->nr);
559 }
560
nr_filters_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)561 static ssize_t nr_filters_store(struct kobject *kobj,
562 struct kobj_attribute *attr, const char *buf, size_t count)
563 {
564 struct damon_sysfs_scheme_filters *filters;
565 int nr, err = kstrtoint(buf, 0, &nr);
566
567 if (err)
568 return err;
569 if (nr < 0)
570 return -EINVAL;
571
572 filters = container_of(kobj, struct damon_sysfs_scheme_filters, kobj);
573
574 if (!mutex_trylock(&damon_sysfs_lock))
575 return -EBUSY;
576 err = damon_sysfs_scheme_filters_add_dirs(filters, nr);
577 mutex_unlock(&damon_sysfs_lock);
578 if (err)
579 return err;
580
581 return count;
582 }
583
damon_sysfs_scheme_filters_release(struct kobject * kobj)584 static void damon_sysfs_scheme_filters_release(struct kobject *kobj)
585 {
586 kfree(container_of(kobj, struct damon_sysfs_scheme_filters, kobj));
587 }
588
589 static struct kobj_attribute damon_sysfs_scheme_filters_nr_attr =
590 __ATTR_RW_MODE(nr_filters, 0600);
591
592 static struct attribute *damon_sysfs_scheme_filters_attrs[] = {
593 &damon_sysfs_scheme_filters_nr_attr.attr,
594 NULL,
595 };
596 ATTRIBUTE_GROUPS(damon_sysfs_scheme_filters);
597
598 static const struct kobj_type damon_sysfs_scheme_filters_ktype = {
599 .release = damon_sysfs_scheme_filters_release,
600 .sysfs_ops = &kobj_sysfs_ops,
601 .default_groups = damon_sysfs_scheme_filters_groups,
602 };
603
604 /*
605 * watermarks directory
606 */
607
608 struct damon_sysfs_watermarks {
609 struct kobject kobj;
610 enum damos_wmark_metric metric;
611 unsigned long interval_us;
612 unsigned long high;
613 unsigned long mid;
614 unsigned long low;
615 };
616
damon_sysfs_watermarks_alloc(enum damos_wmark_metric metric,unsigned long interval_us,unsigned long high,unsigned long mid,unsigned long low)617 static struct damon_sysfs_watermarks *damon_sysfs_watermarks_alloc(
618 enum damos_wmark_metric metric, unsigned long interval_us,
619 unsigned long high, unsigned long mid, unsigned long low)
620 {
621 struct damon_sysfs_watermarks *watermarks = kmalloc(
622 sizeof(*watermarks), GFP_KERNEL);
623
624 if (!watermarks)
625 return NULL;
626 watermarks->kobj = (struct kobject){};
627 watermarks->metric = metric;
628 watermarks->interval_us = interval_us;
629 watermarks->high = high;
630 watermarks->mid = mid;
631 watermarks->low = low;
632 return watermarks;
633 }
634
635 /* Should match with enum damos_wmark_metric */
636 static const char * const damon_sysfs_wmark_metric_strs[] = {
637 "none",
638 "free_mem_rate",
639 };
640
metric_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)641 static ssize_t metric_show(struct kobject *kobj, struct kobj_attribute *attr,
642 char *buf)
643 {
644 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
645 struct damon_sysfs_watermarks, kobj);
646
647 return sysfs_emit(buf, "%s\n",
648 damon_sysfs_wmark_metric_strs[watermarks->metric]);
649 }
650
metric_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)651 static ssize_t metric_store(struct kobject *kobj, struct kobj_attribute *attr,
652 const char *buf, size_t count)
653 {
654 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
655 struct damon_sysfs_watermarks, kobj);
656 enum damos_wmark_metric metric;
657
658 for (metric = 0; metric < NR_DAMOS_WMARK_METRICS; metric++) {
659 if (sysfs_streq(buf, damon_sysfs_wmark_metric_strs[metric])) {
660 watermarks->metric = metric;
661 return count;
662 }
663 }
664 return -EINVAL;
665 }
666
interval_us_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)667 static ssize_t interval_us_show(struct kobject *kobj,
668 struct kobj_attribute *attr, char *buf)
669 {
670 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
671 struct damon_sysfs_watermarks, kobj);
672
673 return sysfs_emit(buf, "%lu\n", watermarks->interval_us);
674 }
675
interval_us_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)676 static ssize_t interval_us_store(struct kobject *kobj,
677 struct kobj_attribute *attr, const char *buf, size_t count)
678 {
679 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
680 struct damon_sysfs_watermarks, kobj);
681 int err = kstrtoul(buf, 0, &watermarks->interval_us);
682
683 return err ? err : count;
684 }
685
high_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)686 static ssize_t high_show(struct kobject *kobj,
687 struct kobj_attribute *attr, char *buf)
688 {
689 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
690 struct damon_sysfs_watermarks, kobj);
691
692 return sysfs_emit(buf, "%lu\n", watermarks->high);
693 }
694
high_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)695 static ssize_t high_store(struct kobject *kobj,
696 struct kobj_attribute *attr, const char *buf, size_t count)
697 {
698 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
699 struct damon_sysfs_watermarks, kobj);
700 int err = kstrtoul(buf, 0, &watermarks->high);
701
702 return err ? err : count;
703 }
704
mid_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)705 static ssize_t mid_show(struct kobject *kobj,
706 struct kobj_attribute *attr, char *buf)
707 {
708 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
709 struct damon_sysfs_watermarks, kobj);
710
711 return sysfs_emit(buf, "%lu\n", watermarks->mid);
712 }
713
mid_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)714 static ssize_t mid_store(struct kobject *kobj,
715 struct kobj_attribute *attr, const char *buf, size_t count)
716 {
717 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
718 struct damon_sysfs_watermarks, kobj);
719 int err = kstrtoul(buf, 0, &watermarks->mid);
720
721 return err ? err : count;
722 }
723
low_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)724 static ssize_t low_show(struct kobject *kobj,
725 struct kobj_attribute *attr, char *buf)
726 {
727 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
728 struct damon_sysfs_watermarks, kobj);
729
730 return sysfs_emit(buf, "%lu\n", watermarks->low);
731 }
732
low_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)733 static ssize_t low_store(struct kobject *kobj,
734 struct kobj_attribute *attr, const char *buf, size_t count)
735 {
736 struct damon_sysfs_watermarks *watermarks = container_of(kobj,
737 struct damon_sysfs_watermarks, kobj);
738 int err = kstrtoul(buf, 0, &watermarks->low);
739
740 return err ? err : count;
741 }
742
damon_sysfs_watermarks_release(struct kobject * kobj)743 static void damon_sysfs_watermarks_release(struct kobject *kobj)
744 {
745 kfree(container_of(kobj, struct damon_sysfs_watermarks, kobj));
746 }
747
748 static struct kobj_attribute damon_sysfs_watermarks_metric_attr =
749 __ATTR_RW_MODE(metric, 0600);
750
751 static struct kobj_attribute damon_sysfs_watermarks_interval_us_attr =
752 __ATTR_RW_MODE(interval_us, 0600);
753
754 static struct kobj_attribute damon_sysfs_watermarks_high_attr =
755 __ATTR_RW_MODE(high, 0600);
756
757 static struct kobj_attribute damon_sysfs_watermarks_mid_attr =
758 __ATTR_RW_MODE(mid, 0600);
759
760 static struct kobj_attribute damon_sysfs_watermarks_low_attr =
761 __ATTR_RW_MODE(low, 0600);
762
763 static struct attribute *damon_sysfs_watermarks_attrs[] = {
764 &damon_sysfs_watermarks_metric_attr.attr,
765 &damon_sysfs_watermarks_interval_us_attr.attr,
766 &damon_sysfs_watermarks_high_attr.attr,
767 &damon_sysfs_watermarks_mid_attr.attr,
768 &damon_sysfs_watermarks_low_attr.attr,
769 NULL,
770 };
771 ATTRIBUTE_GROUPS(damon_sysfs_watermarks);
772
773 static const struct kobj_type damon_sysfs_watermarks_ktype = {
774 .release = damon_sysfs_watermarks_release,
775 .sysfs_ops = &kobj_sysfs_ops,
776 .default_groups = damon_sysfs_watermarks_groups,
777 };
778
779 /*
780 * scheme/weights directory
781 */
782
783 struct damon_sysfs_weights {
784 struct kobject kobj;
785 unsigned int sz;
786 unsigned int nr_accesses;
787 unsigned int age;
788 };
789
damon_sysfs_weights_alloc(unsigned int sz,unsigned int nr_accesses,unsigned int age)790 static struct damon_sysfs_weights *damon_sysfs_weights_alloc(unsigned int sz,
791 unsigned int nr_accesses, unsigned int age)
792 {
793 struct damon_sysfs_weights *weights = kmalloc(sizeof(*weights),
794 GFP_KERNEL);
795
796 if (!weights)
797 return NULL;
798 weights->kobj = (struct kobject){};
799 weights->sz = sz;
800 weights->nr_accesses = nr_accesses;
801 weights->age = age;
802 return weights;
803 }
804
sz_permil_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)805 static ssize_t sz_permil_show(struct kobject *kobj,
806 struct kobj_attribute *attr, char *buf)
807 {
808 struct damon_sysfs_weights *weights = container_of(kobj,
809 struct damon_sysfs_weights, kobj);
810
811 return sysfs_emit(buf, "%u\n", weights->sz);
812 }
813
sz_permil_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)814 static ssize_t sz_permil_store(struct kobject *kobj,
815 struct kobj_attribute *attr, const char *buf, size_t count)
816 {
817 struct damon_sysfs_weights *weights = container_of(kobj,
818 struct damon_sysfs_weights, kobj);
819 int err = kstrtouint(buf, 0, &weights->sz);
820
821 return err ? err : count;
822 }
823
nr_accesses_permil_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)824 static ssize_t nr_accesses_permil_show(struct kobject *kobj,
825 struct kobj_attribute *attr, char *buf)
826 {
827 struct damon_sysfs_weights *weights = container_of(kobj,
828 struct damon_sysfs_weights, kobj);
829
830 return sysfs_emit(buf, "%u\n", weights->nr_accesses);
831 }
832
nr_accesses_permil_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)833 static ssize_t nr_accesses_permil_store(struct kobject *kobj,
834 struct kobj_attribute *attr, const char *buf, size_t count)
835 {
836 struct damon_sysfs_weights *weights = container_of(kobj,
837 struct damon_sysfs_weights, kobj);
838 int err = kstrtouint(buf, 0, &weights->nr_accesses);
839
840 return err ? err : count;
841 }
842
age_permil_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)843 static ssize_t age_permil_show(struct kobject *kobj,
844 struct kobj_attribute *attr, char *buf)
845 {
846 struct damon_sysfs_weights *weights = container_of(kobj,
847 struct damon_sysfs_weights, kobj);
848
849 return sysfs_emit(buf, "%u\n", weights->age);
850 }
851
age_permil_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)852 static ssize_t age_permil_store(struct kobject *kobj,
853 struct kobj_attribute *attr, const char *buf, size_t count)
854 {
855 struct damon_sysfs_weights *weights = container_of(kobj,
856 struct damon_sysfs_weights, kobj);
857 int err = kstrtouint(buf, 0, &weights->age);
858
859 return err ? err : count;
860 }
861
damon_sysfs_weights_release(struct kobject * kobj)862 static void damon_sysfs_weights_release(struct kobject *kobj)
863 {
864 kfree(container_of(kobj, struct damon_sysfs_weights, kobj));
865 }
866
867 static struct kobj_attribute damon_sysfs_weights_sz_attr =
868 __ATTR_RW_MODE(sz_permil, 0600);
869
870 static struct kobj_attribute damon_sysfs_weights_nr_accesses_attr =
871 __ATTR_RW_MODE(nr_accesses_permil, 0600);
872
873 static struct kobj_attribute damon_sysfs_weights_age_attr =
874 __ATTR_RW_MODE(age_permil, 0600);
875
876 static struct attribute *damon_sysfs_weights_attrs[] = {
877 &damon_sysfs_weights_sz_attr.attr,
878 &damon_sysfs_weights_nr_accesses_attr.attr,
879 &damon_sysfs_weights_age_attr.attr,
880 NULL,
881 };
882 ATTRIBUTE_GROUPS(damon_sysfs_weights);
883
884 static const struct kobj_type damon_sysfs_weights_ktype = {
885 .release = damon_sysfs_weights_release,
886 .sysfs_ops = &kobj_sysfs_ops,
887 .default_groups = damon_sysfs_weights_groups,
888 };
889
890 /*
891 * quotas directory
892 */
893
894 struct damon_sysfs_quotas {
895 struct kobject kobj;
896 struct damon_sysfs_weights *weights;
897 unsigned long ms;
898 unsigned long sz;
899 unsigned long reset_interval_ms;
900 };
901
damon_sysfs_quotas_alloc(void)902 static struct damon_sysfs_quotas *damon_sysfs_quotas_alloc(void)
903 {
904 return kzalloc(sizeof(struct damon_sysfs_quotas), GFP_KERNEL);
905 }
906
damon_sysfs_quotas_add_dirs(struct damon_sysfs_quotas * quotas)907 static int damon_sysfs_quotas_add_dirs(struct damon_sysfs_quotas *quotas)
908 {
909 struct damon_sysfs_weights *weights;
910 int err;
911
912 weights = damon_sysfs_weights_alloc(0, 0, 0);
913 if (!weights)
914 return -ENOMEM;
915
916 err = kobject_init_and_add(&weights->kobj, &damon_sysfs_weights_ktype,
917 "as->kobj, "weights");
918 if (err)
919 kobject_put(&weights->kobj);
920 else
921 quotas->weights = weights;
922 return err;
923 }
924
damon_sysfs_quotas_rm_dirs(struct damon_sysfs_quotas * quotas)925 static void damon_sysfs_quotas_rm_dirs(struct damon_sysfs_quotas *quotas)
926 {
927 kobject_put("as->weights->kobj);
928 }
929
ms_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)930 static ssize_t ms_show(struct kobject *kobj, struct kobj_attribute *attr,
931 char *buf)
932 {
933 struct damon_sysfs_quotas *quotas = container_of(kobj,
934 struct damon_sysfs_quotas, kobj);
935
936 return sysfs_emit(buf, "%lu\n", quotas->ms);
937 }
938
ms_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)939 static ssize_t ms_store(struct kobject *kobj, struct kobj_attribute *attr,
940 const char *buf, size_t count)
941 {
942 struct damon_sysfs_quotas *quotas = container_of(kobj,
943 struct damon_sysfs_quotas, kobj);
944 int err = kstrtoul(buf, 0, "as->ms);
945
946 if (err)
947 return -EINVAL;
948 return count;
949 }
950
bytes_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)951 static ssize_t bytes_show(struct kobject *kobj, struct kobj_attribute *attr,
952 char *buf)
953 {
954 struct damon_sysfs_quotas *quotas = container_of(kobj,
955 struct damon_sysfs_quotas, kobj);
956
957 return sysfs_emit(buf, "%lu\n", quotas->sz);
958 }
959
bytes_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)960 static ssize_t bytes_store(struct kobject *kobj,
961 struct kobj_attribute *attr, const char *buf, size_t count)
962 {
963 struct damon_sysfs_quotas *quotas = container_of(kobj,
964 struct damon_sysfs_quotas, kobj);
965 int err = kstrtoul(buf, 0, "as->sz);
966
967 if (err)
968 return -EINVAL;
969 return count;
970 }
971
reset_interval_ms_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)972 static ssize_t reset_interval_ms_show(struct kobject *kobj,
973 struct kobj_attribute *attr, char *buf)
974 {
975 struct damon_sysfs_quotas *quotas = container_of(kobj,
976 struct damon_sysfs_quotas, kobj);
977
978 return sysfs_emit(buf, "%lu\n", quotas->reset_interval_ms);
979 }
980
reset_interval_ms_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)981 static ssize_t reset_interval_ms_store(struct kobject *kobj,
982 struct kobj_attribute *attr, const char *buf, size_t count)
983 {
984 struct damon_sysfs_quotas *quotas = container_of(kobj,
985 struct damon_sysfs_quotas, kobj);
986 int err = kstrtoul(buf, 0, "as->reset_interval_ms);
987
988 if (err)
989 return -EINVAL;
990 return count;
991 }
992
damon_sysfs_quotas_release(struct kobject * kobj)993 static void damon_sysfs_quotas_release(struct kobject *kobj)
994 {
995 kfree(container_of(kobj, struct damon_sysfs_quotas, kobj));
996 }
997
998 static struct kobj_attribute damon_sysfs_quotas_ms_attr =
999 __ATTR_RW_MODE(ms, 0600);
1000
1001 static struct kobj_attribute damon_sysfs_quotas_sz_attr =
1002 __ATTR_RW_MODE(bytes, 0600);
1003
1004 static struct kobj_attribute damon_sysfs_quotas_reset_interval_ms_attr =
1005 __ATTR_RW_MODE(reset_interval_ms, 0600);
1006
1007 static struct attribute *damon_sysfs_quotas_attrs[] = {
1008 &damon_sysfs_quotas_ms_attr.attr,
1009 &damon_sysfs_quotas_sz_attr.attr,
1010 &damon_sysfs_quotas_reset_interval_ms_attr.attr,
1011 NULL,
1012 };
1013 ATTRIBUTE_GROUPS(damon_sysfs_quotas);
1014
1015 static const struct kobj_type damon_sysfs_quotas_ktype = {
1016 .release = damon_sysfs_quotas_release,
1017 .sysfs_ops = &kobj_sysfs_ops,
1018 .default_groups = damon_sysfs_quotas_groups,
1019 };
1020
1021 /*
1022 * access_pattern directory
1023 */
1024
1025 struct damon_sysfs_access_pattern {
1026 struct kobject kobj;
1027 struct damon_sysfs_ul_range *sz;
1028 struct damon_sysfs_ul_range *nr_accesses;
1029 struct damon_sysfs_ul_range *age;
1030 };
1031
1032 static
damon_sysfs_access_pattern_alloc(void)1033 struct damon_sysfs_access_pattern *damon_sysfs_access_pattern_alloc(void)
1034 {
1035 struct damon_sysfs_access_pattern *access_pattern =
1036 kmalloc(sizeof(*access_pattern), GFP_KERNEL);
1037
1038 if (!access_pattern)
1039 return NULL;
1040 access_pattern->kobj = (struct kobject){};
1041 return access_pattern;
1042 }
1043
damon_sysfs_access_pattern_add_range_dir(struct damon_sysfs_access_pattern * access_pattern,struct damon_sysfs_ul_range ** range_dir_ptr,char * name)1044 static int damon_sysfs_access_pattern_add_range_dir(
1045 struct damon_sysfs_access_pattern *access_pattern,
1046 struct damon_sysfs_ul_range **range_dir_ptr,
1047 char *name)
1048 {
1049 struct damon_sysfs_ul_range *range = damon_sysfs_ul_range_alloc(0, 0);
1050 int err;
1051
1052 if (!range)
1053 return -ENOMEM;
1054 err = kobject_init_and_add(&range->kobj, &damon_sysfs_ul_range_ktype,
1055 &access_pattern->kobj, name);
1056 if (err)
1057 kobject_put(&range->kobj);
1058 else
1059 *range_dir_ptr = range;
1060 return err;
1061 }
1062
damon_sysfs_access_pattern_add_dirs(struct damon_sysfs_access_pattern * access_pattern)1063 static int damon_sysfs_access_pattern_add_dirs(
1064 struct damon_sysfs_access_pattern *access_pattern)
1065 {
1066 int err;
1067
1068 err = damon_sysfs_access_pattern_add_range_dir(access_pattern,
1069 &access_pattern->sz, "sz");
1070 if (err)
1071 goto put_sz_out;
1072
1073 err = damon_sysfs_access_pattern_add_range_dir(access_pattern,
1074 &access_pattern->nr_accesses, "nr_accesses");
1075 if (err)
1076 goto put_nr_accesses_sz_out;
1077
1078 err = damon_sysfs_access_pattern_add_range_dir(access_pattern,
1079 &access_pattern->age, "age");
1080 if (err)
1081 goto put_age_nr_accesses_sz_out;
1082 return 0;
1083
1084 put_age_nr_accesses_sz_out:
1085 kobject_put(&access_pattern->age->kobj);
1086 access_pattern->age = NULL;
1087 put_nr_accesses_sz_out:
1088 kobject_put(&access_pattern->nr_accesses->kobj);
1089 access_pattern->nr_accesses = NULL;
1090 put_sz_out:
1091 kobject_put(&access_pattern->sz->kobj);
1092 access_pattern->sz = NULL;
1093 return err;
1094 }
1095
damon_sysfs_access_pattern_rm_dirs(struct damon_sysfs_access_pattern * access_pattern)1096 static void damon_sysfs_access_pattern_rm_dirs(
1097 struct damon_sysfs_access_pattern *access_pattern)
1098 {
1099 kobject_put(&access_pattern->sz->kobj);
1100 kobject_put(&access_pattern->nr_accesses->kobj);
1101 kobject_put(&access_pattern->age->kobj);
1102 }
1103
damon_sysfs_access_pattern_release(struct kobject * kobj)1104 static void damon_sysfs_access_pattern_release(struct kobject *kobj)
1105 {
1106 kfree(container_of(kobj, struct damon_sysfs_access_pattern, kobj));
1107 }
1108
1109 static struct attribute *damon_sysfs_access_pattern_attrs[] = {
1110 NULL,
1111 };
1112 ATTRIBUTE_GROUPS(damon_sysfs_access_pattern);
1113
1114 static const struct kobj_type damon_sysfs_access_pattern_ktype = {
1115 .release = damon_sysfs_access_pattern_release,
1116 .sysfs_ops = &kobj_sysfs_ops,
1117 .default_groups = damon_sysfs_access_pattern_groups,
1118 };
1119
1120 /*
1121 * scheme directory
1122 */
1123
1124 struct damon_sysfs_scheme {
1125 struct kobject kobj;
1126 enum damos_action action;
1127 struct damon_sysfs_access_pattern *access_pattern;
1128 struct damon_sysfs_quotas *quotas;
1129 struct damon_sysfs_watermarks *watermarks;
1130 struct damon_sysfs_scheme_filters *filters;
1131 struct damon_sysfs_stats *stats;
1132 struct damon_sysfs_scheme_regions *tried_regions;
1133 };
1134
1135 /* This should match with enum damos_action */
1136 static const char * const damon_sysfs_damos_action_strs[] = {
1137 "willneed",
1138 "cold",
1139 "pageout",
1140 "hugepage",
1141 "nohugepage",
1142 "lru_prio",
1143 "lru_deprio",
1144 "stat",
1145 };
1146
damon_sysfs_scheme_alloc(enum damos_action action)1147 static struct damon_sysfs_scheme *damon_sysfs_scheme_alloc(
1148 enum damos_action action)
1149 {
1150 struct damon_sysfs_scheme *scheme = kmalloc(sizeof(*scheme),
1151 GFP_KERNEL);
1152
1153 if (!scheme)
1154 return NULL;
1155 scheme->kobj = (struct kobject){};
1156 scheme->action = action;
1157 return scheme;
1158 }
1159
damon_sysfs_scheme_set_access_pattern(struct damon_sysfs_scheme * scheme)1160 static int damon_sysfs_scheme_set_access_pattern(
1161 struct damon_sysfs_scheme *scheme)
1162 {
1163 struct damon_sysfs_access_pattern *access_pattern;
1164 int err;
1165
1166 access_pattern = damon_sysfs_access_pattern_alloc();
1167 if (!access_pattern)
1168 return -ENOMEM;
1169 err = kobject_init_and_add(&access_pattern->kobj,
1170 &damon_sysfs_access_pattern_ktype, &scheme->kobj,
1171 "access_pattern");
1172 if (err)
1173 goto out;
1174 err = damon_sysfs_access_pattern_add_dirs(access_pattern);
1175 if (err)
1176 goto out;
1177 scheme->access_pattern = access_pattern;
1178 return 0;
1179
1180 out:
1181 kobject_put(&access_pattern->kobj);
1182 return err;
1183 }
1184
damon_sysfs_scheme_set_quotas(struct damon_sysfs_scheme * scheme)1185 static int damon_sysfs_scheme_set_quotas(struct damon_sysfs_scheme *scheme)
1186 {
1187 struct damon_sysfs_quotas *quotas = damon_sysfs_quotas_alloc();
1188 int err;
1189
1190 if (!quotas)
1191 return -ENOMEM;
1192 err = kobject_init_and_add("as->kobj, &damon_sysfs_quotas_ktype,
1193 &scheme->kobj, "quotas");
1194 if (err)
1195 goto out;
1196 err = damon_sysfs_quotas_add_dirs(quotas);
1197 if (err)
1198 goto out;
1199 scheme->quotas = quotas;
1200 return 0;
1201
1202 out:
1203 kobject_put("as->kobj);
1204 return err;
1205 }
1206
damon_sysfs_scheme_set_watermarks(struct damon_sysfs_scheme * scheme)1207 static int damon_sysfs_scheme_set_watermarks(struct damon_sysfs_scheme *scheme)
1208 {
1209 struct damon_sysfs_watermarks *watermarks =
1210 damon_sysfs_watermarks_alloc(DAMOS_WMARK_NONE, 0, 0, 0, 0);
1211 int err;
1212
1213 if (!watermarks)
1214 return -ENOMEM;
1215 err = kobject_init_and_add(&watermarks->kobj,
1216 &damon_sysfs_watermarks_ktype, &scheme->kobj,
1217 "watermarks");
1218 if (err)
1219 kobject_put(&watermarks->kobj);
1220 else
1221 scheme->watermarks = watermarks;
1222 return err;
1223 }
1224
damon_sysfs_scheme_set_filters(struct damon_sysfs_scheme * scheme)1225 static int damon_sysfs_scheme_set_filters(struct damon_sysfs_scheme *scheme)
1226 {
1227 struct damon_sysfs_scheme_filters *filters =
1228 damon_sysfs_scheme_filters_alloc();
1229 int err;
1230
1231 if (!filters)
1232 return -ENOMEM;
1233 err = kobject_init_and_add(&filters->kobj,
1234 &damon_sysfs_scheme_filters_ktype, &scheme->kobj,
1235 "filters");
1236 if (err)
1237 kobject_put(&filters->kobj);
1238 else
1239 scheme->filters = filters;
1240 return err;
1241 }
1242
damon_sysfs_scheme_set_stats(struct damon_sysfs_scheme * scheme)1243 static int damon_sysfs_scheme_set_stats(struct damon_sysfs_scheme *scheme)
1244 {
1245 struct damon_sysfs_stats *stats = damon_sysfs_stats_alloc();
1246 int err;
1247
1248 if (!stats)
1249 return -ENOMEM;
1250 err = kobject_init_and_add(&stats->kobj, &damon_sysfs_stats_ktype,
1251 &scheme->kobj, "stats");
1252 if (err)
1253 kobject_put(&stats->kobj);
1254 else
1255 scheme->stats = stats;
1256 return err;
1257 }
1258
damon_sysfs_scheme_set_tried_regions(struct damon_sysfs_scheme * scheme)1259 static int damon_sysfs_scheme_set_tried_regions(
1260 struct damon_sysfs_scheme *scheme)
1261 {
1262 struct damon_sysfs_scheme_regions *tried_regions =
1263 damon_sysfs_scheme_regions_alloc();
1264 int err;
1265
1266 if (!tried_regions)
1267 return -ENOMEM;
1268 err = kobject_init_and_add(&tried_regions->kobj,
1269 &damon_sysfs_scheme_regions_ktype, &scheme->kobj,
1270 "tried_regions");
1271 if (err)
1272 kobject_put(&tried_regions->kobj);
1273 else
1274 scheme->tried_regions = tried_regions;
1275 return err;
1276 }
1277
damon_sysfs_scheme_add_dirs(struct damon_sysfs_scheme * scheme)1278 static int damon_sysfs_scheme_add_dirs(struct damon_sysfs_scheme *scheme)
1279 {
1280 int err;
1281
1282 err = damon_sysfs_scheme_set_access_pattern(scheme);
1283 if (err)
1284 return err;
1285 err = damon_sysfs_scheme_set_quotas(scheme);
1286 if (err)
1287 goto put_access_pattern_out;
1288 err = damon_sysfs_scheme_set_watermarks(scheme);
1289 if (err)
1290 goto put_quotas_access_pattern_out;
1291 err = damon_sysfs_scheme_set_filters(scheme);
1292 if (err)
1293 goto put_watermarks_quotas_access_pattern_out;
1294 err = damon_sysfs_scheme_set_stats(scheme);
1295 if (err)
1296 goto put_filters_watermarks_quotas_access_pattern_out;
1297 err = damon_sysfs_scheme_set_tried_regions(scheme);
1298 if (err)
1299 goto put_tried_regions_out;
1300 return 0;
1301
1302 put_tried_regions_out:
1303 kobject_put(&scheme->tried_regions->kobj);
1304 scheme->tried_regions = NULL;
1305 put_filters_watermarks_quotas_access_pattern_out:
1306 kobject_put(&scheme->filters->kobj);
1307 scheme->filters = NULL;
1308 put_watermarks_quotas_access_pattern_out:
1309 kobject_put(&scheme->watermarks->kobj);
1310 scheme->watermarks = NULL;
1311 put_quotas_access_pattern_out:
1312 kobject_put(&scheme->quotas->kobj);
1313 scheme->quotas = NULL;
1314 put_access_pattern_out:
1315 kobject_put(&scheme->access_pattern->kobj);
1316 scheme->access_pattern = NULL;
1317 return err;
1318 }
1319
damon_sysfs_scheme_rm_dirs(struct damon_sysfs_scheme * scheme)1320 static void damon_sysfs_scheme_rm_dirs(struct damon_sysfs_scheme *scheme)
1321 {
1322 damon_sysfs_access_pattern_rm_dirs(scheme->access_pattern);
1323 kobject_put(&scheme->access_pattern->kobj);
1324 damon_sysfs_quotas_rm_dirs(scheme->quotas);
1325 kobject_put(&scheme->quotas->kobj);
1326 kobject_put(&scheme->watermarks->kobj);
1327 damon_sysfs_scheme_filters_rm_dirs(scheme->filters);
1328 kobject_put(&scheme->filters->kobj);
1329 kobject_put(&scheme->stats->kobj);
1330 damon_sysfs_scheme_regions_rm_dirs(scheme->tried_regions);
1331 kobject_put(&scheme->tried_regions->kobj);
1332 }
1333
action_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)1334 static ssize_t action_show(struct kobject *kobj, struct kobj_attribute *attr,
1335 char *buf)
1336 {
1337 struct damon_sysfs_scheme *scheme = container_of(kobj,
1338 struct damon_sysfs_scheme, kobj);
1339
1340 return sysfs_emit(buf, "%s\n",
1341 damon_sysfs_damos_action_strs[scheme->action]);
1342 }
1343
action_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)1344 static ssize_t action_store(struct kobject *kobj, struct kobj_attribute *attr,
1345 const char *buf, size_t count)
1346 {
1347 struct damon_sysfs_scheme *scheme = container_of(kobj,
1348 struct damon_sysfs_scheme, kobj);
1349 enum damos_action action;
1350
1351 for (action = 0; action < NR_DAMOS_ACTIONS; action++) {
1352 if (sysfs_streq(buf, damon_sysfs_damos_action_strs[action])) {
1353 scheme->action = action;
1354 return count;
1355 }
1356 }
1357 return -EINVAL;
1358 }
1359
damon_sysfs_scheme_release(struct kobject * kobj)1360 static void damon_sysfs_scheme_release(struct kobject *kobj)
1361 {
1362 kfree(container_of(kobj, struct damon_sysfs_scheme, kobj));
1363 }
1364
1365 static struct kobj_attribute damon_sysfs_scheme_action_attr =
1366 __ATTR_RW_MODE(action, 0600);
1367
1368 static struct attribute *damon_sysfs_scheme_attrs[] = {
1369 &damon_sysfs_scheme_action_attr.attr,
1370 NULL,
1371 };
1372 ATTRIBUTE_GROUPS(damon_sysfs_scheme);
1373
1374 static const struct kobj_type damon_sysfs_scheme_ktype = {
1375 .release = damon_sysfs_scheme_release,
1376 .sysfs_ops = &kobj_sysfs_ops,
1377 .default_groups = damon_sysfs_scheme_groups,
1378 };
1379
1380 /*
1381 * schemes directory
1382 */
1383
damon_sysfs_schemes_alloc(void)1384 struct damon_sysfs_schemes *damon_sysfs_schemes_alloc(void)
1385 {
1386 return kzalloc(sizeof(struct damon_sysfs_schemes), GFP_KERNEL);
1387 }
1388
damon_sysfs_schemes_rm_dirs(struct damon_sysfs_schemes * schemes)1389 void damon_sysfs_schemes_rm_dirs(struct damon_sysfs_schemes *schemes)
1390 {
1391 struct damon_sysfs_scheme **schemes_arr = schemes->schemes_arr;
1392 int i;
1393
1394 for (i = 0; i < schemes->nr; i++) {
1395 damon_sysfs_scheme_rm_dirs(schemes_arr[i]);
1396 kobject_put(&schemes_arr[i]->kobj);
1397 }
1398 schemes->nr = 0;
1399 kfree(schemes_arr);
1400 schemes->schemes_arr = NULL;
1401 }
1402
damon_sysfs_schemes_add_dirs(struct damon_sysfs_schemes * schemes,int nr_schemes)1403 static int damon_sysfs_schemes_add_dirs(struct damon_sysfs_schemes *schemes,
1404 int nr_schemes)
1405 {
1406 struct damon_sysfs_scheme **schemes_arr, *scheme;
1407 int err, i;
1408
1409 damon_sysfs_schemes_rm_dirs(schemes);
1410 if (!nr_schemes)
1411 return 0;
1412
1413 schemes_arr = kmalloc_array(nr_schemes, sizeof(*schemes_arr),
1414 GFP_KERNEL | __GFP_NOWARN);
1415 if (!schemes_arr)
1416 return -ENOMEM;
1417 schemes->schemes_arr = schemes_arr;
1418
1419 for (i = 0; i < nr_schemes; i++) {
1420 scheme = damon_sysfs_scheme_alloc(DAMOS_STAT);
1421 if (!scheme) {
1422 damon_sysfs_schemes_rm_dirs(schemes);
1423 return -ENOMEM;
1424 }
1425
1426 err = kobject_init_and_add(&scheme->kobj,
1427 &damon_sysfs_scheme_ktype, &schemes->kobj,
1428 "%d", i);
1429 if (err)
1430 goto out;
1431 err = damon_sysfs_scheme_add_dirs(scheme);
1432 if (err)
1433 goto out;
1434
1435 schemes_arr[i] = scheme;
1436 schemes->nr++;
1437 }
1438 return 0;
1439
1440 out:
1441 damon_sysfs_schemes_rm_dirs(schemes);
1442 kobject_put(&scheme->kobj);
1443 return err;
1444 }
1445
nr_schemes_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)1446 static ssize_t nr_schemes_show(struct kobject *kobj,
1447 struct kobj_attribute *attr, char *buf)
1448 {
1449 struct damon_sysfs_schemes *schemes = container_of(kobj,
1450 struct damon_sysfs_schemes, kobj);
1451
1452 return sysfs_emit(buf, "%d\n", schemes->nr);
1453 }
1454
nr_schemes_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)1455 static ssize_t nr_schemes_store(struct kobject *kobj,
1456 struct kobj_attribute *attr, const char *buf, size_t count)
1457 {
1458 struct damon_sysfs_schemes *schemes;
1459 int nr, err = kstrtoint(buf, 0, &nr);
1460
1461 if (err)
1462 return err;
1463 if (nr < 0)
1464 return -EINVAL;
1465
1466 schemes = container_of(kobj, struct damon_sysfs_schemes, kobj);
1467
1468 if (!mutex_trylock(&damon_sysfs_lock))
1469 return -EBUSY;
1470 err = damon_sysfs_schemes_add_dirs(schemes, nr);
1471 mutex_unlock(&damon_sysfs_lock);
1472 if (err)
1473 return err;
1474 return count;
1475 }
1476
damon_sysfs_schemes_release(struct kobject * kobj)1477 static void damon_sysfs_schemes_release(struct kobject *kobj)
1478 {
1479 kfree(container_of(kobj, struct damon_sysfs_schemes, kobj));
1480 }
1481
1482 static struct kobj_attribute damon_sysfs_schemes_nr_attr =
1483 __ATTR_RW_MODE(nr_schemes, 0600);
1484
1485 static struct attribute *damon_sysfs_schemes_attrs[] = {
1486 &damon_sysfs_schemes_nr_attr.attr,
1487 NULL,
1488 };
1489 ATTRIBUTE_GROUPS(damon_sysfs_schemes);
1490
1491 const struct kobj_type damon_sysfs_schemes_ktype = {
1492 .release = damon_sysfs_schemes_release,
1493 .sysfs_ops = &kobj_sysfs_ops,
1494 .default_groups = damon_sysfs_schemes_groups,
1495 };
1496
damon_sysfs_memcg_path_eq(struct mem_cgroup * memcg,char * memcg_path_buf,char * path)1497 static bool damon_sysfs_memcg_path_eq(struct mem_cgroup *memcg,
1498 char *memcg_path_buf, char *path)
1499 {
1500 #ifdef CONFIG_MEMCG
1501 cgroup_path(memcg->css.cgroup, memcg_path_buf, PATH_MAX);
1502 if (sysfs_streq(memcg_path_buf, path))
1503 return true;
1504 #endif /* CONFIG_MEMCG */
1505 return false;
1506 }
1507
damon_sysfs_memcg_path_to_id(char * memcg_path,unsigned short * id)1508 static int damon_sysfs_memcg_path_to_id(char *memcg_path, unsigned short *id)
1509 {
1510 struct mem_cgroup *memcg;
1511 char *path;
1512 bool found = false;
1513
1514 if (!memcg_path)
1515 return -EINVAL;
1516
1517 path = kmalloc(sizeof(*path) * PATH_MAX, GFP_KERNEL);
1518 if (!path)
1519 return -ENOMEM;
1520
1521 for (memcg = mem_cgroup_iter(NULL, NULL, NULL); memcg;
1522 memcg = mem_cgroup_iter(NULL, memcg, NULL)) {
1523 /* skip removed memcg */
1524 if (!mem_cgroup_id(memcg))
1525 continue;
1526 if (damon_sysfs_memcg_path_eq(memcg, path, memcg_path)) {
1527 *id = mem_cgroup_id(memcg);
1528 found = true;
1529 break;
1530 }
1531 }
1532
1533 kfree(path);
1534 return found ? 0 : -EINVAL;
1535 }
1536
damon_sysfs_set_scheme_filters(struct damos * scheme,struct damon_sysfs_scheme_filters * sysfs_filters)1537 static int damon_sysfs_set_scheme_filters(struct damos *scheme,
1538 struct damon_sysfs_scheme_filters *sysfs_filters)
1539 {
1540 int i;
1541 struct damos_filter *filter, *next;
1542
1543 damos_for_each_filter_safe(filter, next, scheme)
1544 damos_destroy_filter(filter);
1545
1546 for (i = 0; i < sysfs_filters->nr; i++) {
1547 struct damon_sysfs_scheme_filter *sysfs_filter =
1548 sysfs_filters->filters_arr[i];
1549 struct damos_filter *filter =
1550 damos_new_filter(sysfs_filter->type,
1551 sysfs_filter->matching);
1552 int err;
1553
1554 if (!filter)
1555 return -ENOMEM;
1556 if (filter->type == DAMOS_FILTER_TYPE_MEMCG) {
1557 err = damon_sysfs_memcg_path_to_id(
1558 sysfs_filter->memcg_path,
1559 &filter->memcg_id);
1560 if (err) {
1561 damos_destroy_filter(filter);
1562 return err;
1563 }
1564 } else if (filter->type == DAMOS_FILTER_TYPE_ADDR) {
1565 if (sysfs_filter->addr_range.end <
1566 sysfs_filter->addr_range.start) {
1567 damos_destroy_filter(filter);
1568 return -EINVAL;
1569 }
1570 filter->addr_range = sysfs_filter->addr_range;
1571 } else if (filter->type == DAMOS_FILTER_TYPE_TARGET) {
1572 filter->target_idx = sysfs_filter->target_idx;
1573 }
1574
1575 damos_add_filter(scheme, filter);
1576 }
1577 return 0;
1578 }
1579
damon_sysfs_mk_scheme(struct damon_sysfs_scheme * sysfs_scheme)1580 static struct damos *damon_sysfs_mk_scheme(
1581 struct damon_sysfs_scheme *sysfs_scheme)
1582 {
1583 struct damon_sysfs_access_pattern *access_pattern =
1584 sysfs_scheme->access_pattern;
1585 struct damon_sysfs_quotas *sysfs_quotas = sysfs_scheme->quotas;
1586 struct damon_sysfs_weights *sysfs_weights = sysfs_quotas->weights;
1587 struct damon_sysfs_watermarks *sysfs_wmarks = sysfs_scheme->watermarks;
1588 struct damon_sysfs_scheme_filters *sysfs_filters =
1589 sysfs_scheme->filters;
1590 struct damos *scheme;
1591 int err;
1592
1593 struct damos_access_pattern pattern = {
1594 .min_sz_region = access_pattern->sz->min,
1595 .max_sz_region = access_pattern->sz->max,
1596 .min_nr_accesses = access_pattern->nr_accesses->min,
1597 .max_nr_accesses = access_pattern->nr_accesses->max,
1598 .min_age_region = access_pattern->age->min,
1599 .max_age_region = access_pattern->age->max,
1600 };
1601 struct damos_quota quota = {
1602 .ms = sysfs_quotas->ms,
1603 .sz = sysfs_quotas->sz,
1604 .reset_interval = sysfs_quotas->reset_interval_ms,
1605 .weight_sz = sysfs_weights->sz,
1606 .weight_nr_accesses = sysfs_weights->nr_accesses,
1607 .weight_age = sysfs_weights->age,
1608 };
1609 struct damos_watermarks wmarks = {
1610 .metric = sysfs_wmarks->metric,
1611 .interval = sysfs_wmarks->interval_us,
1612 .high = sysfs_wmarks->high,
1613 .mid = sysfs_wmarks->mid,
1614 .low = sysfs_wmarks->low,
1615 };
1616
1617 scheme = damon_new_scheme(&pattern, sysfs_scheme->action, 0, "a,
1618 &wmarks);
1619 if (!scheme)
1620 return NULL;
1621
1622 err = damon_sysfs_set_scheme_filters(scheme, sysfs_filters);
1623 if (err) {
1624 damon_destroy_scheme(scheme);
1625 return NULL;
1626 }
1627 return scheme;
1628 }
1629
damon_sysfs_update_scheme(struct damos * scheme,struct damon_sysfs_scheme * sysfs_scheme)1630 static void damon_sysfs_update_scheme(struct damos *scheme,
1631 struct damon_sysfs_scheme *sysfs_scheme)
1632 {
1633 struct damon_sysfs_access_pattern *access_pattern =
1634 sysfs_scheme->access_pattern;
1635 struct damon_sysfs_quotas *sysfs_quotas = sysfs_scheme->quotas;
1636 struct damon_sysfs_weights *sysfs_weights = sysfs_quotas->weights;
1637 struct damon_sysfs_watermarks *sysfs_wmarks = sysfs_scheme->watermarks;
1638 int err;
1639
1640 scheme->pattern.min_sz_region = access_pattern->sz->min;
1641 scheme->pattern.max_sz_region = access_pattern->sz->max;
1642 scheme->pattern.min_nr_accesses = access_pattern->nr_accesses->min;
1643 scheme->pattern.max_nr_accesses = access_pattern->nr_accesses->max;
1644 scheme->pattern.min_age_region = access_pattern->age->min;
1645 scheme->pattern.max_age_region = access_pattern->age->max;
1646
1647 scheme->action = sysfs_scheme->action;
1648
1649 scheme->quota.ms = sysfs_quotas->ms;
1650 scheme->quota.sz = sysfs_quotas->sz;
1651 scheme->quota.reset_interval = sysfs_quotas->reset_interval_ms;
1652 scheme->quota.weight_sz = sysfs_weights->sz;
1653 scheme->quota.weight_nr_accesses = sysfs_weights->nr_accesses;
1654 scheme->quota.weight_age = sysfs_weights->age;
1655
1656 scheme->wmarks.metric = sysfs_wmarks->metric;
1657 scheme->wmarks.interval = sysfs_wmarks->interval_us;
1658 scheme->wmarks.high = sysfs_wmarks->high;
1659 scheme->wmarks.mid = sysfs_wmarks->mid;
1660 scheme->wmarks.low = sysfs_wmarks->low;
1661
1662 err = damon_sysfs_set_scheme_filters(scheme, sysfs_scheme->filters);
1663 if (err)
1664 damon_destroy_scheme(scheme);
1665 }
1666
damon_sysfs_set_schemes(struct damon_ctx * ctx,struct damon_sysfs_schemes * sysfs_schemes)1667 int damon_sysfs_set_schemes(struct damon_ctx *ctx,
1668 struct damon_sysfs_schemes *sysfs_schemes)
1669 {
1670 struct damos *scheme, *next;
1671 int i = 0;
1672
1673 damon_for_each_scheme_safe(scheme, next, ctx) {
1674 if (i < sysfs_schemes->nr)
1675 damon_sysfs_update_scheme(scheme,
1676 sysfs_schemes->schemes_arr[i]);
1677 else
1678 damon_destroy_scheme(scheme);
1679 i++;
1680 }
1681
1682 for (; i < sysfs_schemes->nr; i++) {
1683 struct damos *scheme, *next;
1684
1685 scheme = damon_sysfs_mk_scheme(sysfs_schemes->schemes_arr[i]);
1686 if (!scheme) {
1687 damon_for_each_scheme_safe(scheme, next, ctx)
1688 damon_destroy_scheme(scheme);
1689 return -ENOMEM;
1690 }
1691 damon_add_scheme(ctx, scheme);
1692 }
1693 return 0;
1694 }
1695
damon_sysfs_schemes_update_stats(struct damon_sysfs_schemes * sysfs_schemes,struct damon_ctx * ctx)1696 void damon_sysfs_schemes_update_stats(
1697 struct damon_sysfs_schemes *sysfs_schemes,
1698 struct damon_ctx *ctx)
1699 {
1700 struct damos *scheme;
1701 int schemes_idx = 0;
1702
1703 damon_for_each_scheme(scheme, ctx) {
1704 struct damon_sysfs_stats *sysfs_stats;
1705
1706 /* user could have removed the scheme sysfs dir */
1707 if (schemes_idx >= sysfs_schemes->nr)
1708 break;
1709
1710 sysfs_stats = sysfs_schemes->schemes_arr[schemes_idx++]->stats;
1711 sysfs_stats->nr_tried = scheme->stat.nr_tried;
1712 sysfs_stats->sz_tried = scheme->stat.sz_tried;
1713 sysfs_stats->nr_applied = scheme->stat.nr_applied;
1714 sysfs_stats->sz_applied = scheme->stat.sz_applied;
1715 sysfs_stats->qt_exceeds = scheme->stat.qt_exceeds;
1716 }
1717 }
1718
1719 /*
1720 * damon_sysfs_schemes that need to update its schemes regions dir. Protected
1721 * by damon_sysfs_lock
1722 */
1723 static struct damon_sysfs_schemes *damon_sysfs_schemes_for_damos_callback;
1724 static int damon_sysfs_schemes_region_idx;
1725 static bool damos_regions_upd_total_bytes_only;
1726
1727 /*
1728 * DAMON callback that called before damos apply. While this callback is
1729 * registered, damon_sysfs_lock should be held to ensure the regions
1730 * directories exist.
1731 */
damon_sysfs_before_damos_apply(struct damon_ctx * ctx,struct damon_target * t,struct damon_region * r,struct damos * s)1732 static int damon_sysfs_before_damos_apply(struct damon_ctx *ctx,
1733 struct damon_target *t, struct damon_region *r,
1734 struct damos *s)
1735 {
1736 struct damos *scheme;
1737 struct damon_sysfs_scheme_regions *sysfs_regions;
1738 struct damon_sysfs_scheme_region *region;
1739 struct damon_sysfs_schemes *sysfs_schemes =
1740 damon_sysfs_schemes_for_damos_callback;
1741 int schemes_idx = 0;
1742
1743 damon_for_each_scheme(scheme, ctx) {
1744 if (scheme == s)
1745 break;
1746 schemes_idx++;
1747 }
1748
1749 /* user could have removed the scheme sysfs dir */
1750 if (schemes_idx >= sysfs_schemes->nr)
1751 return 0;
1752
1753 sysfs_regions = sysfs_schemes->schemes_arr[schemes_idx]->tried_regions;
1754 sysfs_regions->total_bytes += r->ar.end - r->ar.start;
1755 if (damos_regions_upd_total_bytes_only)
1756 return 0;
1757
1758 region = damon_sysfs_scheme_region_alloc(r);
1759 if (!region)
1760 return 0;
1761 list_add_tail(®ion->list, &sysfs_regions->regions_list);
1762 sysfs_regions->nr_regions++;
1763 if (kobject_init_and_add(®ion->kobj,
1764 &damon_sysfs_scheme_region_ktype,
1765 &sysfs_regions->kobj, "%d",
1766 damon_sysfs_schemes_region_idx++)) {
1767 kobject_put(®ion->kobj);
1768 }
1769 return 0;
1770 }
1771
1772 /* Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock */
damon_sysfs_schemes_clear_regions(struct damon_sysfs_schemes * sysfs_schemes,struct damon_ctx * ctx)1773 int damon_sysfs_schemes_clear_regions(
1774 struct damon_sysfs_schemes *sysfs_schemes,
1775 struct damon_ctx *ctx)
1776 {
1777 struct damos *scheme;
1778 int schemes_idx = 0;
1779
1780 damon_for_each_scheme(scheme, ctx) {
1781 struct damon_sysfs_scheme *sysfs_scheme;
1782
1783 /* user could have removed the scheme sysfs dir */
1784 if (schemes_idx >= sysfs_schemes->nr)
1785 break;
1786
1787 sysfs_scheme = sysfs_schemes->schemes_arr[schemes_idx++];
1788 damon_sysfs_scheme_regions_rm_dirs(
1789 sysfs_scheme->tried_regions);
1790 sysfs_scheme->tried_regions->total_bytes = 0;
1791 }
1792 return 0;
1793 }
1794
1795 /* Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock */
damon_sysfs_schemes_update_regions_start(struct damon_sysfs_schemes * sysfs_schemes,struct damon_ctx * ctx,bool total_bytes_only)1796 int damon_sysfs_schemes_update_regions_start(
1797 struct damon_sysfs_schemes *sysfs_schemes,
1798 struct damon_ctx *ctx, bool total_bytes_only)
1799 {
1800 damon_sysfs_schemes_clear_regions(sysfs_schemes, ctx);
1801 damon_sysfs_schemes_for_damos_callback = sysfs_schemes;
1802 damos_regions_upd_total_bytes_only = total_bytes_only;
1803 ctx->callback.before_damos_apply = damon_sysfs_before_damos_apply;
1804 return 0;
1805 }
1806
1807 /*
1808 * Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock. Caller
1809 * should unlock damon_sysfs_lock which held before
1810 * damon_sysfs_schemes_update_regions_start()
1811 */
damon_sysfs_schemes_update_regions_stop(struct damon_ctx * ctx)1812 int damon_sysfs_schemes_update_regions_stop(struct damon_ctx *ctx)
1813 {
1814 damon_sysfs_schemes_for_damos_callback = NULL;
1815 ctx->callback.before_damos_apply = NULL;
1816 damon_sysfs_schemes_region_idx = 0;
1817 return 0;
1818 }
1819