xref: /openbmc/linux/mm/damon/sysfs-schemes.c (revision 7df45f35313c1ae083dac72c066b3aebfc7fc0cd)
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(&region->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(&regions->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, &regions->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 			&quotas->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(&quotas->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, &quotas->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, &quotas->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, &quotas->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(&quotas->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(&quotas->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, &quota,
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(&region->list, &sysfs_regions->regions_list);
1762 	sysfs_regions->nr_regions++;
1763 	if (kobject_init_and_add(&region->kobj,
1764 				&damon_sysfs_scheme_region_ktype,
1765 				&sysfs_regions->kobj, "%d",
1766 				damon_sysfs_schemes_region_idx++)) {
1767 		kobject_put(&region->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