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/pid.h>
9 #include <linux/sched.h>
10 #include <linux/slab.h>
11
12 #include "sysfs-common.h"
13
14 /*
15 * init region directory
16 */
17
18 struct damon_sysfs_region {
19 struct kobject kobj;
20 struct damon_addr_range ar;
21 };
22
23 static struct damon_sysfs_region *damon_sysfs_region_alloc(void)
24 {
25 return kzalloc(sizeof(struct damon_sysfs_region), GFP_KERNEL);
26 }
27
28 static ssize_t start_show(struct kobject *kobj, struct kobj_attribute *attr,
29 char *buf)
30 {
31 struct damon_sysfs_region *region = container_of(kobj,
32 struct damon_sysfs_region, kobj);
33
34 return sysfs_emit(buf, "%lu\n", region->ar.start);
35 }
36
37 static ssize_t start_store(struct kobject *kobj, struct kobj_attribute *attr,
38 const char *buf, size_t count)
39 {
40 struct damon_sysfs_region *region = container_of(kobj,
41 struct damon_sysfs_region, kobj);
42 int err = kstrtoul(buf, 0, ®ion->ar.start);
43
44 return err ? err : count;
45 }
46
47 static ssize_t end_show(struct kobject *kobj, struct kobj_attribute *attr,
48 char *buf)
49 {
50 struct damon_sysfs_region *region = container_of(kobj,
51 struct damon_sysfs_region, kobj);
52
53 return sysfs_emit(buf, "%lu\n", region->ar.end);
54 }
55
56 static ssize_t end_store(struct kobject *kobj, struct kobj_attribute *attr,
57 const char *buf, size_t count)
58 {
59 struct damon_sysfs_region *region = container_of(kobj,
60 struct damon_sysfs_region, kobj);
61 int err = kstrtoul(buf, 0, ®ion->ar.end);
62
63 return err ? err : count;
64 }
65
66 static void damon_sysfs_region_release(struct kobject *kobj)
67 {
68 kfree(container_of(kobj, struct damon_sysfs_region, kobj));
69 }
70
71 static struct kobj_attribute damon_sysfs_region_start_attr =
72 __ATTR_RW_MODE(start, 0600);
73
74 static struct kobj_attribute damon_sysfs_region_end_attr =
75 __ATTR_RW_MODE(end, 0600);
76
77 static struct attribute *damon_sysfs_region_attrs[] = {
78 &damon_sysfs_region_start_attr.attr,
79 &damon_sysfs_region_end_attr.attr,
80 NULL,
81 };
82 ATTRIBUTE_GROUPS(damon_sysfs_region);
83
84 static const struct kobj_type damon_sysfs_region_ktype = {
85 .release = damon_sysfs_region_release,
86 .sysfs_ops = &kobj_sysfs_ops,
87 .default_groups = damon_sysfs_region_groups,
88 };
89
90 /*
91 * init_regions directory
92 */
93
94 struct damon_sysfs_regions {
95 struct kobject kobj;
96 struct damon_sysfs_region **regions_arr;
97 int nr;
98 };
99
100 static struct damon_sysfs_regions *damon_sysfs_regions_alloc(void)
101 {
102 return kzalloc(sizeof(struct damon_sysfs_regions), GFP_KERNEL);
103 }
104
105 static void damon_sysfs_regions_rm_dirs(struct damon_sysfs_regions *regions)
106 {
107 struct damon_sysfs_region **regions_arr = regions->regions_arr;
108 int i;
109
110 for (i = 0; i < regions->nr; i++)
111 kobject_put(®ions_arr[i]->kobj);
112 regions->nr = 0;
113 kfree(regions_arr);
114 regions->regions_arr = NULL;
115 }
116
117 static int damon_sysfs_regions_add_dirs(struct damon_sysfs_regions *regions,
118 int nr_regions)
119 {
120 struct damon_sysfs_region **regions_arr, *region;
121 int err, i;
122
123 damon_sysfs_regions_rm_dirs(regions);
124 if (!nr_regions)
125 return 0;
126
127 regions_arr = kmalloc_array(nr_regions, sizeof(*regions_arr),
128 GFP_KERNEL | __GFP_NOWARN);
129 if (!regions_arr)
130 return -ENOMEM;
131 regions->regions_arr = regions_arr;
132
133 for (i = 0; i < nr_regions; i++) {
134 region = damon_sysfs_region_alloc();
135 if (!region) {
136 damon_sysfs_regions_rm_dirs(regions);
137 return -ENOMEM;
138 }
139
140 err = kobject_init_and_add(®ion->kobj,
141 &damon_sysfs_region_ktype, ®ions->kobj,
142 "%d", i);
143 if (err) {
144 kobject_put(®ion->kobj);
145 damon_sysfs_regions_rm_dirs(regions);
146 return err;
147 }
148
149 regions_arr[i] = region;
150 regions->nr++;
151 }
152 return 0;
153 }
154
155 static ssize_t nr_regions_show(struct kobject *kobj,
156 struct kobj_attribute *attr, char *buf)
157 {
158 struct damon_sysfs_regions *regions = container_of(kobj,
159 struct damon_sysfs_regions, kobj);
160
161 return sysfs_emit(buf, "%d\n", regions->nr);
162 }
163
164 static ssize_t nr_regions_store(struct kobject *kobj,
165 struct kobj_attribute *attr, const char *buf, size_t count)
166 {
167 struct damon_sysfs_regions *regions;
168 int nr, err = kstrtoint(buf, 0, &nr);
169
170 if (err)
171 return err;
172 if (nr < 0)
173 return -EINVAL;
174
175 regions = container_of(kobj, struct damon_sysfs_regions, kobj);
176
177 if (!mutex_trylock(&damon_sysfs_lock))
178 return -EBUSY;
179 err = damon_sysfs_regions_add_dirs(regions, nr);
180 mutex_unlock(&damon_sysfs_lock);
181 if (err)
182 return err;
183
184 return count;
185 }
186
187 static void damon_sysfs_regions_release(struct kobject *kobj)
188 {
189 kfree(container_of(kobj, struct damon_sysfs_regions, kobj));
190 }
191
192 static struct kobj_attribute damon_sysfs_regions_nr_attr =
193 __ATTR_RW_MODE(nr_regions, 0600);
194
195 static struct attribute *damon_sysfs_regions_attrs[] = {
196 &damon_sysfs_regions_nr_attr.attr,
197 NULL,
198 };
199 ATTRIBUTE_GROUPS(damon_sysfs_regions);
200
201 static const struct kobj_type damon_sysfs_regions_ktype = {
202 .release = damon_sysfs_regions_release,
203 .sysfs_ops = &kobj_sysfs_ops,
204 .default_groups = damon_sysfs_regions_groups,
205 };
206
207 /*
208 * target directory
209 */
210
211 struct damon_sysfs_target {
212 struct kobject kobj;
213 struct damon_sysfs_regions *regions;
214 int pid;
215 };
216
217 static struct damon_sysfs_target *damon_sysfs_target_alloc(void)
218 {
219 return kzalloc(sizeof(struct damon_sysfs_target), GFP_KERNEL);
220 }
221
222 static int damon_sysfs_target_add_dirs(struct damon_sysfs_target *target)
223 {
224 struct damon_sysfs_regions *regions = damon_sysfs_regions_alloc();
225 int err;
226
227 if (!regions)
228 return -ENOMEM;
229
230 err = kobject_init_and_add(®ions->kobj, &damon_sysfs_regions_ktype,
231 &target->kobj, "regions");
232 if (err)
233 kobject_put(®ions->kobj);
234 else
235 target->regions = regions;
236 return err;
237 }
238
239 static void damon_sysfs_target_rm_dirs(struct damon_sysfs_target *target)
240 {
241 damon_sysfs_regions_rm_dirs(target->regions);
242 kobject_put(&target->regions->kobj);
243 }
244
245 static ssize_t pid_target_show(struct kobject *kobj,
246 struct kobj_attribute *attr, char *buf)
247 {
248 struct damon_sysfs_target *target = container_of(kobj,
249 struct damon_sysfs_target, kobj);
250
251 return sysfs_emit(buf, "%d\n", target->pid);
252 }
253
254 static ssize_t pid_target_store(struct kobject *kobj,
255 struct kobj_attribute *attr, const char *buf, size_t count)
256 {
257 struct damon_sysfs_target *target = container_of(kobj,
258 struct damon_sysfs_target, kobj);
259 int err = kstrtoint(buf, 0, &target->pid);
260
261 if (err)
262 return -EINVAL;
263 return count;
264 }
265
266 static void damon_sysfs_target_release(struct kobject *kobj)
267 {
268 kfree(container_of(kobj, struct damon_sysfs_target, kobj));
269 }
270
271 static struct kobj_attribute damon_sysfs_target_pid_attr =
272 __ATTR_RW_MODE(pid_target, 0600);
273
274 static struct attribute *damon_sysfs_target_attrs[] = {
275 &damon_sysfs_target_pid_attr.attr,
276 NULL,
277 };
278 ATTRIBUTE_GROUPS(damon_sysfs_target);
279
280 static const struct kobj_type damon_sysfs_target_ktype = {
281 .release = damon_sysfs_target_release,
282 .sysfs_ops = &kobj_sysfs_ops,
283 .default_groups = damon_sysfs_target_groups,
284 };
285
286 /*
287 * targets directory
288 */
289
290 struct damon_sysfs_targets {
291 struct kobject kobj;
292 struct damon_sysfs_target **targets_arr;
293 int nr;
294 };
295
296 static struct damon_sysfs_targets *damon_sysfs_targets_alloc(void)
297 {
298 return kzalloc(sizeof(struct damon_sysfs_targets), GFP_KERNEL);
299 }
300
301 static void damon_sysfs_targets_rm_dirs(struct damon_sysfs_targets *targets)
302 {
303 struct damon_sysfs_target **targets_arr = targets->targets_arr;
304 int i;
305
306 for (i = 0; i < targets->nr; i++) {
307 damon_sysfs_target_rm_dirs(targets_arr[i]);
308 kobject_put(&targets_arr[i]->kobj);
309 }
310 targets->nr = 0;
311 kfree(targets_arr);
312 targets->targets_arr = NULL;
313 }
314
315 static int damon_sysfs_targets_add_dirs(struct damon_sysfs_targets *targets,
316 int nr_targets)
317 {
318 struct damon_sysfs_target **targets_arr, *target;
319 int err, i;
320
321 damon_sysfs_targets_rm_dirs(targets);
322 if (!nr_targets)
323 return 0;
324
325 targets_arr = kmalloc_array(nr_targets, sizeof(*targets_arr),
326 GFP_KERNEL | __GFP_NOWARN);
327 if (!targets_arr)
328 return -ENOMEM;
329 targets->targets_arr = targets_arr;
330
331 for (i = 0; i < nr_targets; i++) {
332 target = damon_sysfs_target_alloc();
333 if (!target) {
334 damon_sysfs_targets_rm_dirs(targets);
335 return -ENOMEM;
336 }
337
338 err = kobject_init_and_add(&target->kobj,
339 &damon_sysfs_target_ktype, &targets->kobj,
340 "%d", i);
341 if (err)
342 goto out;
343
344 err = damon_sysfs_target_add_dirs(target);
345 if (err)
346 goto out;
347
348 targets_arr[i] = target;
349 targets->nr++;
350 }
351 return 0;
352
353 out:
354 damon_sysfs_targets_rm_dirs(targets);
355 kobject_put(&target->kobj);
356 return err;
357 }
358
359 static ssize_t nr_targets_show(struct kobject *kobj,
360 struct kobj_attribute *attr, char *buf)
361 {
362 struct damon_sysfs_targets *targets = container_of(kobj,
363 struct damon_sysfs_targets, kobj);
364
365 return sysfs_emit(buf, "%d\n", targets->nr);
366 }
367
368 static ssize_t nr_targets_store(struct kobject *kobj,
369 struct kobj_attribute *attr, const char *buf, size_t count)
370 {
371 struct damon_sysfs_targets *targets;
372 int nr, err = kstrtoint(buf, 0, &nr);
373
374 if (err)
375 return err;
376 if (nr < 0)
377 return -EINVAL;
378
379 targets = container_of(kobj, struct damon_sysfs_targets, kobj);
380
381 if (!mutex_trylock(&damon_sysfs_lock))
382 return -EBUSY;
383 err = damon_sysfs_targets_add_dirs(targets, nr);
384 mutex_unlock(&damon_sysfs_lock);
385 if (err)
386 return err;
387
388 return count;
389 }
390
391 static void damon_sysfs_targets_release(struct kobject *kobj)
392 {
393 kfree(container_of(kobj, struct damon_sysfs_targets, kobj));
394 }
395
396 static struct kobj_attribute damon_sysfs_targets_nr_attr =
397 __ATTR_RW_MODE(nr_targets, 0600);
398
399 static struct attribute *damon_sysfs_targets_attrs[] = {
400 &damon_sysfs_targets_nr_attr.attr,
401 NULL,
402 };
403 ATTRIBUTE_GROUPS(damon_sysfs_targets);
404
405 static const struct kobj_type damon_sysfs_targets_ktype = {
406 .release = damon_sysfs_targets_release,
407 .sysfs_ops = &kobj_sysfs_ops,
408 .default_groups = damon_sysfs_targets_groups,
409 };
410
411 /*
412 * intervals directory
413 */
414
415 struct damon_sysfs_intervals {
416 struct kobject kobj;
417 unsigned long sample_us;
418 unsigned long aggr_us;
419 unsigned long update_us;
420 };
421
422 static struct damon_sysfs_intervals *damon_sysfs_intervals_alloc(
423 unsigned long sample_us, unsigned long aggr_us,
424 unsigned long update_us)
425 {
426 struct damon_sysfs_intervals *intervals = kmalloc(sizeof(*intervals),
427 GFP_KERNEL);
428
429 if (!intervals)
430 return NULL;
431
432 intervals->kobj = (struct kobject){};
433 intervals->sample_us = sample_us;
434 intervals->aggr_us = aggr_us;
435 intervals->update_us = update_us;
436 return intervals;
437 }
438
439 static ssize_t sample_us_show(struct kobject *kobj,
440 struct kobj_attribute *attr, char *buf)
441 {
442 struct damon_sysfs_intervals *intervals = container_of(kobj,
443 struct damon_sysfs_intervals, kobj);
444
445 return sysfs_emit(buf, "%lu\n", intervals->sample_us);
446 }
447
448 static ssize_t sample_us_store(struct kobject *kobj,
449 struct kobj_attribute *attr, const char *buf, size_t count)
450 {
451 struct damon_sysfs_intervals *intervals = container_of(kobj,
452 struct damon_sysfs_intervals, kobj);
453 unsigned long us;
454 int err = kstrtoul(buf, 0, &us);
455
456 if (err)
457 return err;
458
459 intervals->sample_us = us;
460 return count;
461 }
462
463 static ssize_t aggr_us_show(struct kobject *kobj, struct kobj_attribute *attr,
464 char *buf)
465 {
466 struct damon_sysfs_intervals *intervals = container_of(kobj,
467 struct damon_sysfs_intervals, kobj);
468
469 return sysfs_emit(buf, "%lu\n", intervals->aggr_us);
470 }
471
472 static ssize_t aggr_us_store(struct kobject *kobj, struct kobj_attribute *attr,
473 const char *buf, size_t count)
474 {
475 struct damon_sysfs_intervals *intervals = container_of(kobj,
476 struct damon_sysfs_intervals, kobj);
477 unsigned long us;
478 int err = kstrtoul(buf, 0, &us);
479
480 if (err)
481 return err;
482
483 intervals->aggr_us = us;
484 return count;
485 }
486
487 static ssize_t update_us_show(struct kobject *kobj,
488 struct kobj_attribute *attr, char *buf)
489 {
490 struct damon_sysfs_intervals *intervals = container_of(kobj,
491 struct damon_sysfs_intervals, kobj);
492
493 return sysfs_emit(buf, "%lu\n", intervals->update_us);
494 }
495
496 static ssize_t update_us_store(struct kobject *kobj,
497 struct kobj_attribute *attr, const char *buf, size_t count)
498 {
499 struct damon_sysfs_intervals *intervals = container_of(kobj,
500 struct damon_sysfs_intervals, kobj);
501 unsigned long us;
502 int err = kstrtoul(buf, 0, &us);
503
504 if (err)
505 return err;
506
507 intervals->update_us = us;
508 return count;
509 }
510
511 static void damon_sysfs_intervals_release(struct kobject *kobj)
512 {
513 kfree(container_of(kobj, struct damon_sysfs_intervals, kobj));
514 }
515
516 static struct kobj_attribute damon_sysfs_intervals_sample_us_attr =
517 __ATTR_RW_MODE(sample_us, 0600);
518
519 static struct kobj_attribute damon_sysfs_intervals_aggr_us_attr =
520 __ATTR_RW_MODE(aggr_us, 0600);
521
522 static struct kobj_attribute damon_sysfs_intervals_update_us_attr =
523 __ATTR_RW_MODE(update_us, 0600);
524
525 static struct attribute *damon_sysfs_intervals_attrs[] = {
526 &damon_sysfs_intervals_sample_us_attr.attr,
527 &damon_sysfs_intervals_aggr_us_attr.attr,
528 &damon_sysfs_intervals_update_us_attr.attr,
529 NULL,
530 };
531 ATTRIBUTE_GROUPS(damon_sysfs_intervals);
532
533 static const struct kobj_type damon_sysfs_intervals_ktype = {
534 .release = damon_sysfs_intervals_release,
535 .sysfs_ops = &kobj_sysfs_ops,
536 .default_groups = damon_sysfs_intervals_groups,
537 };
538
539 /*
540 * monitoring_attrs directory
541 */
542
543 struct damon_sysfs_attrs {
544 struct kobject kobj;
545 struct damon_sysfs_intervals *intervals;
546 struct damon_sysfs_ul_range *nr_regions_range;
547 };
548
549 static struct damon_sysfs_attrs *damon_sysfs_attrs_alloc(void)
550 {
551 struct damon_sysfs_attrs *attrs = kmalloc(sizeof(*attrs), GFP_KERNEL);
552
553 if (!attrs)
554 return NULL;
555 attrs->kobj = (struct kobject){};
556 return attrs;
557 }
558
559 static int damon_sysfs_attrs_add_dirs(struct damon_sysfs_attrs *attrs)
560 {
561 struct damon_sysfs_intervals *intervals;
562 struct damon_sysfs_ul_range *nr_regions_range;
563 int err;
564
565 intervals = damon_sysfs_intervals_alloc(5000, 100000, 60000000);
566 if (!intervals)
567 return -ENOMEM;
568
569 err = kobject_init_and_add(&intervals->kobj,
570 &damon_sysfs_intervals_ktype, &attrs->kobj,
571 "intervals");
572 if (err)
573 goto put_intervals_out;
574 attrs->intervals = intervals;
575
576 nr_regions_range = damon_sysfs_ul_range_alloc(10, 1000);
577 if (!nr_regions_range) {
578 err = -ENOMEM;
579 goto put_intervals_out;
580 }
581
582 err = kobject_init_and_add(&nr_regions_range->kobj,
583 &damon_sysfs_ul_range_ktype, &attrs->kobj,
584 "nr_regions");
585 if (err)
586 goto put_nr_regions_intervals_out;
587 attrs->nr_regions_range = nr_regions_range;
588 return 0;
589
590 put_nr_regions_intervals_out:
591 kobject_put(&nr_regions_range->kobj);
592 attrs->nr_regions_range = NULL;
593 put_intervals_out:
594 kobject_put(&intervals->kobj);
595 attrs->intervals = NULL;
596 return err;
597 }
598
599 static void damon_sysfs_attrs_rm_dirs(struct damon_sysfs_attrs *attrs)
600 {
601 kobject_put(&attrs->nr_regions_range->kobj);
602 kobject_put(&attrs->intervals->kobj);
603 }
604
605 static void damon_sysfs_attrs_release(struct kobject *kobj)
606 {
607 kfree(container_of(kobj, struct damon_sysfs_attrs, kobj));
608 }
609
610 static struct attribute *damon_sysfs_attrs_attrs[] = {
611 NULL,
612 };
613 ATTRIBUTE_GROUPS(damon_sysfs_attrs);
614
615 static const struct kobj_type damon_sysfs_attrs_ktype = {
616 .release = damon_sysfs_attrs_release,
617 .sysfs_ops = &kobj_sysfs_ops,
618 .default_groups = damon_sysfs_attrs_groups,
619 };
620
621 /*
622 * context directory
623 */
624
625 /* This should match with enum damon_ops_id */
626 static const char * const damon_sysfs_ops_strs[] = {
627 "vaddr",
628 "fvaddr",
629 "paddr",
630 };
631
632 struct damon_sysfs_context {
633 struct kobject kobj;
634 enum damon_ops_id ops_id;
635 struct damon_sysfs_attrs *attrs;
636 struct damon_sysfs_targets *targets;
637 struct damon_sysfs_schemes *schemes;
638 };
639
640 static struct damon_sysfs_context *damon_sysfs_context_alloc(
641 enum damon_ops_id ops_id)
642 {
643 struct damon_sysfs_context *context = kmalloc(sizeof(*context),
644 GFP_KERNEL);
645
646 if (!context)
647 return NULL;
648 context->kobj = (struct kobject){};
649 context->ops_id = ops_id;
650 return context;
651 }
652
653 static int damon_sysfs_context_set_attrs(struct damon_sysfs_context *context)
654 {
655 struct damon_sysfs_attrs *attrs = damon_sysfs_attrs_alloc();
656 int err;
657
658 if (!attrs)
659 return -ENOMEM;
660 err = kobject_init_and_add(&attrs->kobj, &damon_sysfs_attrs_ktype,
661 &context->kobj, "monitoring_attrs");
662 if (err)
663 goto out;
664 err = damon_sysfs_attrs_add_dirs(attrs);
665 if (err)
666 goto out;
667 context->attrs = attrs;
668 return 0;
669
670 out:
671 kobject_put(&attrs->kobj);
672 return err;
673 }
674
675 static int damon_sysfs_context_set_targets(struct damon_sysfs_context *context)
676 {
677 struct damon_sysfs_targets *targets = damon_sysfs_targets_alloc();
678 int err;
679
680 if (!targets)
681 return -ENOMEM;
682 err = kobject_init_and_add(&targets->kobj, &damon_sysfs_targets_ktype,
683 &context->kobj, "targets");
684 if (err) {
685 kobject_put(&targets->kobj);
686 return err;
687 }
688 context->targets = targets;
689 return 0;
690 }
691
692 static int damon_sysfs_context_set_schemes(struct damon_sysfs_context *context)
693 {
694 struct damon_sysfs_schemes *schemes = damon_sysfs_schemes_alloc();
695 int err;
696
697 if (!schemes)
698 return -ENOMEM;
699 err = kobject_init_and_add(&schemes->kobj, &damon_sysfs_schemes_ktype,
700 &context->kobj, "schemes");
701 if (err) {
702 kobject_put(&schemes->kobj);
703 return err;
704 }
705 context->schemes = schemes;
706 return 0;
707 }
708
709 static int damon_sysfs_context_add_dirs(struct damon_sysfs_context *context)
710 {
711 int err;
712
713 err = damon_sysfs_context_set_attrs(context);
714 if (err)
715 return err;
716
717 err = damon_sysfs_context_set_targets(context);
718 if (err)
719 goto put_attrs_out;
720
721 err = damon_sysfs_context_set_schemes(context);
722 if (err)
723 goto put_targets_attrs_out;
724 return 0;
725
726 put_targets_attrs_out:
727 kobject_put(&context->targets->kobj);
728 context->targets = NULL;
729 put_attrs_out:
730 kobject_put(&context->attrs->kobj);
731 context->attrs = NULL;
732 return err;
733 }
734
735 static void damon_sysfs_context_rm_dirs(struct damon_sysfs_context *context)
736 {
737 damon_sysfs_attrs_rm_dirs(context->attrs);
738 kobject_put(&context->attrs->kobj);
739 damon_sysfs_targets_rm_dirs(context->targets);
740 kobject_put(&context->targets->kobj);
741 damon_sysfs_schemes_rm_dirs(context->schemes);
742 kobject_put(&context->schemes->kobj);
743 }
744
745 static ssize_t avail_operations_show(struct kobject *kobj,
746 struct kobj_attribute *attr, char *buf)
747 {
748 enum damon_ops_id id;
749 int len = 0;
750
751 for (id = 0; id < NR_DAMON_OPS; id++) {
752 if (!damon_is_registered_ops(id))
753 continue;
754 len += sysfs_emit_at(buf, len, "%s\n",
755 damon_sysfs_ops_strs[id]);
756 }
757 return len;
758 }
759
760 static ssize_t operations_show(struct kobject *kobj,
761 struct kobj_attribute *attr, char *buf)
762 {
763 struct damon_sysfs_context *context = container_of(kobj,
764 struct damon_sysfs_context, kobj);
765
766 return sysfs_emit(buf, "%s\n", damon_sysfs_ops_strs[context->ops_id]);
767 }
768
769 static ssize_t operations_store(struct kobject *kobj,
770 struct kobj_attribute *attr, const char *buf, size_t count)
771 {
772 struct damon_sysfs_context *context = container_of(kobj,
773 struct damon_sysfs_context, kobj);
774 enum damon_ops_id id;
775
776 for (id = 0; id < NR_DAMON_OPS; id++) {
777 if (sysfs_streq(buf, damon_sysfs_ops_strs[id])) {
778 context->ops_id = id;
779 return count;
780 }
781 }
782 return -EINVAL;
783 }
784
785 static void damon_sysfs_context_release(struct kobject *kobj)
786 {
787 kfree(container_of(kobj, struct damon_sysfs_context, kobj));
788 }
789
790 static struct kobj_attribute damon_sysfs_context_avail_operations_attr =
791 __ATTR_RO_MODE(avail_operations, 0400);
792
793 static struct kobj_attribute damon_sysfs_context_operations_attr =
794 __ATTR_RW_MODE(operations, 0600);
795
796 static struct attribute *damon_sysfs_context_attrs[] = {
797 &damon_sysfs_context_avail_operations_attr.attr,
798 &damon_sysfs_context_operations_attr.attr,
799 NULL,
800 };
801 ATTRIBUTE_GROUPS(damon_sysfs_context);
802
803 static const struct kobj_type damon_sysfs_context_ktype = {
804 .release = damon_sysfs_context_release,
805 .sysfs_ops = &kobj_sysfs_ops,
806 .default_groups = damon_sysfs_context_groups,
807 };
808
809 /*
810 * contexts directory
811 */
812
813 struct damon_sysfs_contexts {
814 struct kobject kobj;
815 struct damon_sysfs_context **contexts_arr;
816 int nr;
817 };
818
819 static struct damon_sysfs_contexts *damon_sysfs_contexts_alloc(void)
820 {
821 return kzalloc(sizeof(struct damon_sysfs_contexts), GFP_KERNEL);
822 }
823
824 static void damon_sysfs_contexts_rm_dirs(struct damon_sysfs_contexts *contexts)
825 {
826 struct damon_sysfs_context **contexts_arr = contexts->contexts_arr;
827 int i;
828
829 for (i = 0; i < contexts->nr; i++) {
830 damon_sysfs_context_rm_dirs(contexts_arr[i]);
831 kobject_put(&contexts_arr[i]->kobj);
832 }
833 contexts->nr = 0;
834 kfree(contexts_arr);
835 contexts->contexts_arr = NULL;
836 }
837
838 static int damon_sysfs_contexts_add_dirs(struct damon_sysfs_contexts *contexts,
839 int nr_contexts)
840 {
841 struct damon_sysfs_context **contexts_arr, *context;
842 int err, i;
843
844 damon_sysfs_contexts_rm_dirs(contexts);
845 if (!nr_contexts)
846 return 0;
847
848 contexts_arr = kmalloc_array(nr_contexts, sizeof(*contexts_arr),
849 GFP_KERNEL | __GFP_NOWARN);
850 if (!contexts_arr)
851 return -ENOMEM;
852 contexts->contexts_arr = contexts_arr;
853
854 for (i = 0; i < nr_contexts; i++) {
855 context = damon_sysfs_context_alloc(DAMON_OPS_VADDR);
856 if (!context) {
857 damon_sysfs_contexts_rm_dirs(contexts);
858 return -ENOMEM;
859 }
860
861 err = kobject_init_and_add(&context->kobj,
862 &damon_sysfs_context_ktype, &contexts->kobj,
863 "%d", i);
864 if (err)
865 goto out;
866
867 err = damon_sysfs_context_add_dirs(context);
868 if (err)
869 goto out;
870
871 contexts_arr[i] = context;
872 contexts->nr++;
873 }
874 return 0;
875
876 out:
877 damon_sysfs_contexts_rm_dirs(contexts);
878 kobject_put(&context->kobj);
879 return err;
880 }
881
882 static ssize_t nr_contexts_show(struct kobject *kobj,
883 struct kobj_attribute *attr, char *buf)
884 {
885 struct damon_sysfs_contexts *contexts = container_of(kobj,
886 struct damon_sysfs_contexts, kobj);
887
888 return sysfs_emit(buf, "%d\n", contexts->nr);
889 }
890
891 static ssize_t nr_contexts_store(struct kobject *kobj,
892 struct kobj_attribute *attr, const char *buf, size_t count)
893 {
894 struct damon_sysfs_contexts *contexts;
895 int nr, err;
896
897 err = kstrtoint(buf, 0, &nr);
898 if (err)
899 return err;
900 /* TODO: support multiple contexts per kdamond */
901 if (nr < 0 || 1 < nr)
902 return -EINVAL;
903
904 contexts = container_of(kobj, struct damon_sysfs_contexts, kobj);
905 if (!mutex_trylock(&damon_sysfs_lock))
906 return -EBUSY;
907 err = damon_sysfs_contexts_add_dirs(contexts, nr);
908 mutex_unlock(&damon_sysfs_lock);
909 if (err)
910 return err;
911
912 return count;
913 }
914
915 static void damon_sysfs_contexts_release(struct kobject *kobj)
916 {
917 kfree(container_of(kobj, struct damon_sysfs_contexts, kobj));
918 }
919
920 static struct kobj_attribute damon_sysfs_contexts_nr_attr
921 = __ATTR_RW_MODE(nr_contexts, 0600);
922
923 static struct attribute *damon_sysfs_contexts_attrs[] = {
924 &damon_sysfs_contexts_nr_attr.attr,
925 NULL,
926 };
927 ATTRIBUTE_GROUPS(damon_sysfs_contexts);
928
929 static const struct kobj_type damon_sysfs_contexts_ktype = {
930 .release = damon_sysfs_contexts_release,
931 .sysfs_ops = &kobj_sysfs_ops,
932 .default_groups = damon_sysfs_contexts_groups,
933 };
934
935 /*
936 * kdamond directory
937 */
938
939 struct damon_sysfs_kdamond {
940 struct kobject kobj;
941 struct damon_sysfs_contexts *contexts;
942 struct damon_ctx *damon_ctx;
943 };
944
945 static struct damon_sysfs_kdamond *damon_sysfs_kdamond_alloc(void)
946 {
947 return kzalloc(sizeof(struct damon_sysfs_kdamond), GFP_KERNEL);
948 }
949
950 static int damon_sysfs_kdamond_add_dirs(struct damon_sysfs_kdamond *kdamond)
951 {
952 struct damon_sysfs_contexts *contexts;
953 int err;
954
955 contexts = damon_sysfs_contexts_alloc();
956 if (!contexts)
957 return -ENOMEM;
958
959 err = kobject_init_and_add(&contexts->kobj,
960 &damon_sysfs_contexts_ktype, &kdamond->kobj,
961 "contexts");
962 if (err) {
963 kobject_put(&contexts->kobj);
964 return err;
965 }
966 kdamond->contexts = contexts;
967
968 return err;
969 }
970
971 static void damon_sysfs_kdamond_rm_dirs(struct damon_sysfs_kdamond *kdamond)
972 {
973 damon_sysfs_contexts_rm_dirs(kdamond->contexts);
974 kobject_put(&kdamond->contexts->kobj);
975 }
976
977 static bool damon_sysfs_ctx_running(struct damon_ctx *ctx)
978 {
979 bool running;
980
981 mutex_lock(&ctx->kdamond_lock);
982 running = ctx->kdamond != NULL;
983 mutex_unlock(&ctx->kdamond_lock);
984 return running;
985 }
986
987 /*
988 * enum damon_sysfs_cmd - Commands for a specific kdamond.
989 */
990 enum damon_sysfs_cmd {
991 /* @DAMON_SYSFS_CMD_ON: Turn the kdamond on. */
992 DAMON_SYSFS_CMD_ON,
993 /* @DAMON_SYSFS_CMD_OFF: Turn the kdamond off. */
994 DAMON_SYSFS_CMD_OFF,
995 /* @DAMON_SYSFS_CMD_COMMIT: Update kdamond inputs. */
996 DAMON_SYSFS_CMD_COMMIT,
997 /*
998 * @DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS: Commit the quota goals
999 * to DAMON.
1000 */
1001 DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS,
1002 /*
1003 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS: Update scheme stats sysfs
1004 * files.
1005 */
1006 DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS,
1007 /*
1008 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES: Update
1009 * tried_regions/total_bytes sysfs files for each scheme.
1010 */
1011 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES,
1012 /*
1013 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS: Update schemes tried
1014 * regions
1015 */
1016 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS,
1017 /*
1018 * @DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS: Clear schemes tried
1019 * regions
1020 */
1021 DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS,
1022 /*
1023 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS: Update the
1024 * effective size quota of the scheme in bytes.
1025 */
1026 DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS,
1027 /*
1028 * @NR_DAMON_SYSFS_CMDS: Total number of DAMON sysfs commands.
1029 */
1030 NR_DAMON_SYSFS_CMDS,
1031 };
1032
1033 /* Should match with enum damon_sysfs_cmd */
1034 static const char * const damon_sysfs_cmd_strs[] = {
1035 "on",
1036 "off",
1037 "commit",
1038 "commit_schemes_quota_goals",
1039 "update_schemes_stats",
1040 "update_schemes_tried_bytes",
1041 "update_schemes_tried_regions",
1042 "clear_schemes_tried_regions",
1043 "update_schemes_effective_quotas",
1044 };
1045
1046 /*
1047 * struct damon_sysfs_cmd_request - A request to the DAMON callback.
1048 * @cmd: The command that needs to be handled by the callback.
1049 * @kdamond: The kobject wrapper that associated to the kdamond thread.
1050 *
1051 * This structure represents a sysfs command request that need to access some
1052 * DAMON context-internal data. Because DAMON context-internal data can be
1053 * safely accessed from DAMON callbacks without additional synchronization, the
1054 * request will be handled by the DAMON callback. None-``NULL`` @kdamond means
1055 * the request is valid.
1056 */
1057 struct damon_sysfs_cmd_request {
1058 enum damon_sysfs_cmd cmd;
1059 struct damon_sysfs_kdamond *kdamond;
1060 };
1061
1062 /* Current DAMON callback request. Protected by damon_sysfs_lock. */
1063 static struct damon_sysfs_cmd_request damon_sysfs_cmd_request;
1064
1065 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
1066 char *buf)
1067 {
1068 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1069 struct damon_sysfs_kdamond, kobj);
1070 struct damon_ctx *ctx = kdamond->damon_ctx;
1071 bool running;
1072
1073 if (!ctx)
1074 running = false;
1075 else
1076 running = damon_sysfs_ctx_running(ctx);
1077
1078 return sysfs_emit(buf, "%s\n", running ?
1079 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_ON] :
1080 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_OFF]);
1081 }
1082
1083 static int damon_sysfs_set_attrs(struct damon_ctx *ctx,
1084 struct damon_sysfs_attrs *sys_attrs)
1085 {
1086 struct damon_sysfs_intervals *sys_intervals = sys_attrs->intervals;
1087 struct damon_sysfs_ul_range *sys_nr_regions =
1088 sys_attrs->nr_regions_range;
1089 struct damon_attrs attrs = {
1090 .sample_interval = sys_intervals->sample_us,
1091 .aggr_interval = sys_intervals->aggr_us,
1092 .ops_update_interval = sys_intervals->update_us,
1093 .min_nr_regions = sys_nr_regions->min,
1094 .max_nr_regions = sys_nr_regions->max,
1095 };
1096 return damon_set_attrs(ctx, &attrs);
1097 }
1098
1099 static void damon_sysfs_destroy_targets(struct damon_ctx *ctx)
1100 {
1101 struct damon_target *t, *next;
1102 bool has_pid = damon_target_has_pid(ctx);
1103
1104 damon_for_each_target_safe(t, next, ctx) {
1105 if (has_pid)
1106 put_pid(t->pid);
1107 damon_destroy_target(t);
1108 }
1109 }
1110
1111 static int damon_sysfs_set_regions(struct damon_target *t,
1112 struct damon_sysfs_regions *sysfs_regions)
1113 {
1114 struct damon_addr_range *ranges = kmalloc_array(sysfs_regions->nr,
1115 sizeof(*ranges), GFP_KERNEL | __GFP_NOWARN);
1116 int i, err = -EINVAL;
1117
1118 if (!ranges)
1119 return -ENOMEM;
1120 for (i = 0; i < sysfs_regions->nr; i++) {
1121 struct damon_sysfs_region *sys_region =
1122 sysfs_regions->regions_arr[i];
1123
1124 if (sys_region->ar.start > sys_region->ar.end)
1125 goto out;
1126
1127 ranges[i].start = sys_region->ar.start;
1128 ranges[i].end = sys_region->ar.end;
1129 if (i == 0)
1130 continue;
1131 if (ranges[i - 1].end > ranges[i].start)
1132 goto out;
1133 }
1134 err = damon_set_regions(t, ranges, sysfs_regions->nr);
1135 out:
1136 kfree(ranges);
1137 return err;
1138
1139 }
1140
1141 static int damon_sysfs_add_target(struct damon_sysfs_target *sys_target,
1142 struct damon_ctx *ctx)
1143 {
1144 struct damon_target *t = damon_new_target();
1145 int err = -EINVAL;
1146
1147 if (!t)
1148 return -ENOMEM;
1149 damon_add_target(ctx, t);
1150 if (damon_target_has_pid(ctx)) {
1151 t->pid = find_get_pid(sys_target->pid);
1152 if (!t->pid)
1153 goto destroy_targets_out;
1154 }
1155 err = damon_sysfs_set_regions(t, sys_target->regions);
1156 if (err)
1157 goto destroy_targets_out;
1158 return 0;
1159
1160 destroy_targets_out:
1161 damon_sysfs_destroy_targets(ctx);
1162 return err;
1163 }
1164
1165 static int damon_sysfs_add_targets(struct damon_ctx *ctx,
1166 struct damon_sysfs_targets *sysfs_targets)
1167 {
1168 int i, err;
1169
1170 /* Multiple physical address space monitoring targets makes no sense */
1171 if (ctx->ops.id == DAMON_OPS_PADDR && sysfs_targets->nr > 1)
1172 return -EINVAL;
1173
1174 for (i = 0; i < sysfs_targets->nr; i++) {
1175 struct damon_sysfs_target *st = sysfs_targets->targets_arr[i];
1176
1177 err = damon_sysfs_add_target(st, ctx);
1178 if (err)
1179 return err;
1180 }
1181 return 0;
1182 }
1183
1184 static bool damon_sysfs_schemes_regions_updating;
1185
1186 static void damon_sysfs_before_terminate(struct damon_ctx *ctx)
1187 {
1188 struct damon_target *t, *next;
1189 struct damon_sysfs_kdamond *kdamond;
1190 enum damon_sysfs_cmd cmd;
1191
1192 /* damon_sysfs_schemes_update_regions_stop() might not yet called */
1193 kdamond = damon_sysfs_cmd_request.kdamond;
1194 cmd = damon_sysfs_cmd_request.cmd;
1195 if (kdamond && ctx == kdamond->damon_ctx &&
1196 (cmd == DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS ||
1197 cmd == DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES) &&
1198 damon_sysfs_schemes_regions_updating) {
1199 damon_sysfs_schemes_update_regions_stop(ctx);
1200 damon_sysfs_schemes_regions_updating = false;
1201 mutex_unlock(&damon_sysfs_lock);
1202 }
1203
1204 if (!damon_target_has_pid(ctx))
1205 return;
1206
1207 mutex_lock(&ctx->kdamond_lock);
1208 damon_for_each_target_safe(t, next, ctx) {
1209 put_pid(t->pid);
1210 damon_destroy_target(t);
1211 }
1212 mutex_unlock(&ctx->kdamond_lock);
1213 }
1214
1215 /*
1216 * damon_sysfs_upd_schemes_stats() - Update schemes stats sysfs files.
1217 * @kdamond: The kobject wrapper that associated to the kdamond thread.
1218 *
1219 * This function reads the schemes stats of specific kdamond and update the
1220 * related values for sysfs files. This function should be called from DAMON
1221 * callbacks while holding ``damon_syfs_lock``, to safely access the DAMON
1222 * contexts-internal data and DAMON sysfs variables.
1223 */
1224 static int damon_sysfs_upd_schemes_stats(struct damon_sysfs_kdamond *kdamond)
1225 {
1226 struct damon_ctx *ctx = kdamond->damon_ctx;
1227
1228 if (!ctx)
1229 return -EINVAL;
1230 damon_sysfs_schemes_update_stats(
1231 kdamond->contexts->contexts_arr[0]->schemes, ctx);
1232 return 0;
1233 }
1234
1235 static int damon_sysfs_upd_schemes_regions_start(
1236 struct damon_sysfs_kdamond *kdamond, bool total_bytes_only)
1237 {
1238 struct damon_ctx *ctx = kdamond->damon_ctx;
1239
1240 if (!ctx)
1241 return -EINVAL;
1242 return damon_sysfs_schemes_update_regions_start(
1243 kdamond->contexts->contexts_arr[0]->schemes, ctx,
1244 total_bytes_only);
1245 }
1246
1247 static int damon_sysfs_upd_schemes_regions_stop(
1248 struct damon_sysfs_kdamond *kdamond)
1249 {
1250 struct damon_ctx *ctx = kdamond->damon_ctx;
1251
1252 if (!ctx)
1253 return -EINVAL;
1254 return damon_sysfs_schemes_update_regions_stop(ctx);
1255 }
1256
1257 static int damon_sysfs_clear_schemes_regions(
1258 struct damon_sysfs_kdamond *kdamond)
1259 {
1260 struct damon_ctx *ctx = kdamond->damon_ctx;
1261
1262 if (!ctx)
1263 return -EINVAL;
1264 return damon_sysfs_schemes_clear_regions(
1265 kdamond->contexts->contexts_arr[0]->schemes, ctx);
1266 }
1267
1268 static inline bool damon_sysfs_kdamond_running(
1269 struct damon_sysfs_kdamond *kdamond)
1270 {
1271 return kdamond->damon_ctx &&
1272 damon_sysfs_ctx_running(kdamond->damon_ctx);
1273 }
1274
1275 static int damon_sysfs_apply_inputs(struct damon_ctx *ctx,
1276 struct damon_sysfs_context *sys_ctx)
1277 {
1278 int err;
1279
1280 err = damon_select_ops(ctx, sys_ctx->ops_id);
1281 if (err)
1282 return err;
1283 err = damon_sysfs_set_attrs(ctx, sys_ctx->attrs);
1284 if (err)
1285 return err;
1286 err = damon_sysfs_add_targets(ctx, sys_ctx->targets);
1287 if (err)
1288 return err;
1289 return damon_sysfs_add_schemes(ctx, sys_ctx->schemes);
1290 }
1291
1292 static struct damon_ctx *damon_sysfs_build_ctx(
1293 struct damon_sysfs_context *sys_ctx);
1294
1295 /*
1296 * damon_sysfs_commit_input() - Commit user inputs to a running kdamond.
1297 * @kdamond: The kobject wrapper for the associated kdamond.
1298 *
1299 * If the sysfs input is wrong, the kdamond will be terminated.
1300 */
1301 static int damon_sysfs_commit_input(struct damon_sysfs_kdamond *kdamond)
1302 {
1303 struct damon_ctx *param_ctx;
1304 int err;
1305
1306 if (!damon_sysfs_kdamond_running(kdamond))
1307 return -EINVAL;
1308 /* TODO: Support multiple contexts per kdamond */
1309 if (kdamond->contexts->nr != 1)
1310 return -EINVAL;
1311
1312 param_ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]);
1313 if (IS_ERR(param_ctx))
1314 return PTR_ERR(param_ctx);
1315 err = damon_commit_ctx(kdamond->damon_ctx, param_ctx);
1316 damon_sysfs_destroy_targets(param_ctx);
1317 damon_destroy_ctx(param_ctx);
1318 return err;
1319 }
1320
1321 static int damon_sysfs_commit_schemes_quota_goals(
1322 struct damon_sysfs_kdamond *sysfs_kdamond)
1323 {
1324 struct damon_ctx *ctx;
1325 struct damon_sysfs_context *sysfs_ctx;
1326
1327 if (!damon_sysfs_kdamond_running(sysfs_kdamond))
1328 return -EINVAL;
1329 /* TODO: Support multiple contexts per kdamond */
1330 if (sysfs_kdamond->contexts->nr != 1)
1331 return -EINVAL;
1332
1333 ctx = sysfs_kdamond->damon_ctx;
1334 sysfs_ctx = sysfs_kdamond->contexts->contexts_arr[0];
1335 return damos_sysfs_set_quota_scores(sysfs_ctx->schemes, ctx);
1336 }
1337
1338 /*
1339 * damon_sysfs_upd_schemes_effective_quotas() - Update schemes effective quotas
1340 * sysfs files.
1341 * @kdamond: The kobject wrapper that associated to the kdamond thread.
1342 *
1343 * This function reads the schemes' effective quotas of specific kdamond and
1344 * update the related values for sysfs files. This function should be called
1345 * from DAMON callbacks while holding ``damon_syfs_lock``, to safely access the
1346 * DAMON contexts-internal data and DAMON sysfs variables.
1347 */
1348 static int damon_sysfs_upd_schemes_effective_quotas(
1349 struct damon_sysfs_kdamond *kdamond)
1350 {
1351 struct damon_ctx *ctx = kdamond->damon_ctx;
1352
1353 if (!ctx)
1354 return -EINVAL;
1355 damos_sysfs_update_effective_quotas(
1356 kdamond->contexts->contexts_arr[0]->schemes, ctx);
1357 return 0;
1358 }
1359
1360
1361 /*
1362 * damon_sysfs_cmd_request_callback() - DAMON callback for handling requests.
1363 * @c: The DAMON context of the callback.
1364 * @active: Whether @c is not deactivated due to watermarks.
1365 * @after_aggr: Whether this is called from after_aggregation() callback.
1366 *
1367 * This function is periodically called back from the kdamond thread for @c.
1368 * Then, it checks if there is a waiting DAMON sysfs request and handles it.
1369 */
1370 static int damon_sysfs_cmd_request_callback(struct damon_ctx *c, bool active,
1371 bool after_aggregation)
1372 {
1373 struct damon_sysfs_kdamond *kdamond;
1374 bool total_bytes_only = false;
1375 int err = 0;
1376
1377 /* avoid deadlock due to concurrent state_store('off') */
1378 if (!damon_sysfs_schemes_regions_updating &&
1379 !mutex_trylock(&damon_sysfs_lock))
1380 return 0;
1381 kdamond = damon_sysfs_cmd_request.kdamond;
1382 if (!kdamond || kdamond->damon_ctx != c)
1383 goto out;
1384 switch (damon_sysfs_cmd_request.cmd) {
1385 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS:
1386 err = damon_sysfs_upd_schemes_stats(kdamond);
1387 break;
1388 case DAMON_SYSFS_CMD_COMMIT:
1389 if (!after_aggregation)
1390 goto out;
1391 err = damon_sysfs_commit_input(kdamond);
1392 break;
1393 case DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS:
1394 err = damon_sysfs_commit_schemes_quota_goals(kdamond);
1395 break;
1396 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES:
1397 total_bytes_only = true;
1398 fallthrough;
1399 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS:
1400 if (!damon_sysfs_schemes_regions_updating) {
1401 err = damon_sysfs_upd_schemes_regions_start(kdamond,
1402 total_bytes_only);
1403 if (!err) {
1404 damon_sysfs_schemes_regions_updating = true;
1405 goto keep_lock_out;
1406 }
1407 } else {
1408 damos_sysfs_mark_finished_regions_updates(c);
1409 /*
1410 * Continue regions updating if DAMON is till
1411 * active and the update for all schemes is not
1412 * finished.
1413 */
1414 if (active && !damos_sysfs_regions_upd_done())
1415 goto keep_lock_out;
1416 err = damon_sysfs_upd_schemes_regions_stop(kdamond);
1417 damon_sysfs_schemes_regions_updating = false;
1418 }
1419 break;
1420 case DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS:
1421 err = damon_sysfs_clear_schemes_regions(kdamond);
1422 break;
1423 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS:
1424 err = damon_sysfs_upd_schemes_effective_quotas(kdamond);
1425 break;
1426 default:
1427 break;
1428 }
1429 /* Mark the request as invalid now. */
1430 damon_sysfs_cmd_request.kdamond = NULL;
1431 out:
1432 if (!damon_sysfs_schemes_regions_updating)
1433 mutex_unlock(&damon_sysfs_lock);
1434 keep_lock_out:
1435 return err;
1436 }
1437
1438 static int damon_sysfs_after_wmarks_check(struct damon_ctx *c)
1439 {
1440 /*
1441 * after_wmarks_check() is called back while the context is deactivated
1442 * by watermarks.
1443 */
1444 return damon_sysfs_cmd_request_callback(c, false, false);
1445 }
1446
1447 static int damon_sysfs_after_sampling(struct damon_ctx *c)
1448 {
1449 /*
1450 * after_sampling() is called back only while the context is not
1451 * deactivated by watermarks.
1452 */
1453 return damon_sysfs_cmd_request_callback(c, true, false);
1454 }
1455
1456 static int damon_sysfs_after_aggregation(struct damon_ctx *c)
1457 {
1458 /*
1459 * after_aggregation() is called back only while the context is not
1460 * deactivated by watermarks.
1461 */
1462 return damon_sysfs_cmd_request_callback(c, true, true);
1463 }
1464
1465 static struct damon_ctx *damon_sysfs_build_ctx(
1466 struct damon_sysfs_context *sys_ctx)
1467 {
1468 struct damon_ctx *ctx = damon_new_ctx();
1469 int err;
1470
1471 if (!ctx)
1472 return ERR_PTR(-ENOMEM);
1473
1474 err = damon_sysfs_apply_inputs(ctx, sys_ctx);
1475 if (err) {
1476 damon_destroy_ctx(ctx);
1477 return ERR_PTR(err);
1478 }
1479
1480 ctx->callback.after_wmarks_check = damon_sysfs_after_wmarks_check;
1481 ctx->callback.after_sampling = damon_sysfs_after_sampling;
1482 ctx->callback.after_aggregation = damon_sysfs_after_aggregation;
1483 ctx->callback.before_terminate = damon_sysfs_before_terminate;
1484 return ctx;
1485 }
1486
1487 static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond)
1488 {
1489 struct damon_ctx *ctx;
1490 int err;
1491
1492 if (damon_sysfs_kdamond_running(kdamond))
1493 return -EBUSY;
1494 if (damon_sysfs_cmd_request.kdamond == kdamond)
1495 return -EBUSY;
1496 /* TODO: support multiple contexts per kdamond */
1497 if (kdamond->contexts->nr != 1)
1498 return -EINVAL;
1499
1500 if (kdamond->damon_ctx)
1501 damon_destroy_ctx(kdamond->damon_ctx);
1502 kdamond->damon_ctx = NULL;
1503
1504 ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]);
1505 if (IS_ERR(ctx))
1506 return PTR_ERR(ctx);
1507 err = damon_start(&ctx, 1, false);
1508 if (err) {
1509 damon_destroy_ctx(ctx);
1510 return err;
1511 }
1512 kdamond->damon_ctx = ctx;
1513 return err;
1514 }
1515
1516 static int damon_sysfs_turn_damon_off(struct damon_sysfs_kdamond *kdamond)
1517 {
1518 if (!kdamond->damon_ctx)
1519 return -EINVAL;
1520 return damon_stop(&kdamond->damon_ctx, 1);
1521 /*
1522 * To allow users show final monitoring results of already turned-off
1523 * DAMON, we free kdamond->damon_ctx in next
1524 * damon_sysfs_turn_damon_on(), or kdamonds_nr_store()
1525 */
1526 }
1527
1528 /*
1529 * damon_sysfs_handle_cmd() - Handle a command for a specific kdamond.
1530 * @cmd: The command to handle.
1531 * @kdamond: The kobject wrapper for the associated kdamond.
1532 *
1533 * This function handles a DAMON sysfs command for a kdamond. For commands
1534 * that need to access running DAMON context-internal data, it requests
1535 * handling of the command to the DAMON callback
1536 * (@damon_sysfs_cmd_request_callback()) and wait until it is properly handled,
1537 * or the context is completed.
1538 *
1539 * Return: 0 on success, negative error code otherwise.
1540 */
1541 static int damon_sysfs_handle_cmd(enum damon_sysfs_cmd cmd,
1542 struct damon_sysfs_kdamond *kdamond)
1543 {
1544 bool need_wait = true;
1545
1546 /* Handle commands that doesn't access DAMON context-internal data */
1547 switch (cmd) {
1548 case DAMON_SYSFS_CMD_ON:
1549 return damon_sysfs_turn_damon_on(kdamond);
1550 case DAMON_SYSFS_CMD_OFF:
1551 return damon_sysfs_turn_damon_off(kdamond);
1552 default:
1553 break;
1554 }
1555
1556 /* Pass the command to DAMON callback for safe DAMON context access */
1557 if (damon_sysfs_cmd_request.kdamond)
1558 return -EBUSY;
1559 if (!damon_sysfs_kdamond_running(kdamond))
1560 return -EINVAL;
1561 damon_sysfs_cmd_request.cmd = cmd;
1562 damon_sysfs_cmd_request.kdamond = kdamond;
1563
1564 /*
1565 * wait until damon_sysfs_cmd_request_callback() handles the request
1566 * from kdamond context
1567 */
1568 mutex_unlock(&damon_sysfs_lock);
1569 while (need_wait) {
1570 schedule_timeout_idle(msecs_to_jiffies(100));
1571 if (!mutex_trylock(&damon_sysfs_lock))
1572 continue;
1573 if (!damon_sysfs_cmd_request.kdamond) {
1574 /* damon_sysfs_cmd_request_callback() handled */
1575 need_wait = false;
1576 } else if (!damon_sysfs_kdamond_running(kdamond)) {
1577 /* kdamond has already finished */
1578 need_wait = false;
1579 damon_sysfs_cmd_request.kdamond = NULL;
1580 }
1581 mutex_unlock(&damon_sysfs_lock);
1582 }
1583 mutex_lock(&damon_sysfs_lock);
1584 return 0;
1585 }
1586
1587 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
1588 const char *buf, size_t count)
1589 {
1590 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1591 struct damon_sysfs_kdamond, kobj);
1592 enum damon_sysfs_cmd cmd;
1593 ssize_t ret = -EINVAL;
1594
1595 if (!mutex_trylock(&damon_sysfs_lock))
1596 return -EBUSY;
1597 for (cmd = 0; cmd < NR_DAMON_SYSFS_CMDS; cmd++) {
1598 if (sysfs_streq(buf, damon_sysfs_cmd_strs[cmd])) {
1599 ret = damon_sysfs_handle_cmd(cmd, kdamond);
1600 break;
1601 }
1602 }
1603 mutex_unlock(&damon_sysfs_lock);
1604 if (!ret)
1605 ret = count;
1606 return ret;
1607 }
1608
1609 static ssize_t pid_show(struct kobject *kobj,
1610 struct kobj_attribute *attr, char *buf)
1611 {
1612 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1613 struct damon_sysfs_kdamond, kobj);
1614 struct damon_ctx *ctx;
1615 int pid = -1;
1616
1617 if (!mutex_trylock(&damon_sysfs_lock))
1618 return -EBUSY;
1619 ctx = kdamond->damon_ctx;
1620 if (!ctx)
1621 goto out;
1622
1623 mutex_lock(&ctx->kdamond_lock);
1624 if (ctx->kdamond)
1625 pid = ctx->kdamond->pid;
1626 mutex_unlock(&ctx->kdamond_lock);
1627 out:
1628 mutex_unlock(&damon_sysfs_lock);
1629 return sysfs_emit(buf, "%d\n", pid);
1630 }
1631
1632 static void damon_sysfs_kdamond_release(struct kobject *kobj)
1633 {
1634 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1635 struct damon_sysfs_kdamond, kobj);
1636
1637 if (kdamond->damon_ctx)
1638 damon_destroy_ctx(kdamond->damon_ctx);
1639 kfree(kdamond);
1640 }
1641
1642 static struct kobj_attribute damon_sysfs_kdamond_state_attr =
1643 __ATTR_RW_MODE(state, 0600);
1644
1645 static struct kobj_attribute damon_sysfs_kdamond_pid_attr =
1646 __ATTR_RO_MODE(pid, 0400);
1647
1648 static struct attribute *damon_sysfs_kdamond_attrs[] = {
1649 &damon_sysfs_kdamond_state_attr.attr,
1650 &damon_sysfs_kdamond_pid_attr.attr,
1651 NULL,
1652 };
1653 ATTRIBUTE_GROUPS(damon_sysfs_kdamond);
1654
1655 static const struct kobj_type damon_sysfs_kdamond_ktype = {
1656 .release = damon_sysfs_kdamond_release,
1657 .sysfs_ops = &kobj_sysfs_ops,
1658 .default_groups = damon_sysfs_kdamond_groups,
1659 };
1660
1661 /*
1662 * kdamonds directory
1663 */
1664
1665 struct damon_sysfs_kdamonds {
1666 struct kobject kobj;
1667 struct damon_sysfs_kdamond **kdamonds_arr;
1668 int nr;
1669 };
1670
1671 static struct damon_sysfs_kdamonds *damon_sysfs_kdamonds_alloc(void)
1672 {
1673 return kzalloc(sizeof(struct damon_sysfs_kdamonds), GFP_KERNEL);
1674 }
1675
1676 static void damon_sysfs_kdamonds_rm_dirs(struct damon_sysfs_kdamonds *kdamonds)
1677 {
1678 struct damon_sysfs_kdamond **kdamonds_arr = kdamonds->kdamonds_arr;
1679 int i;
1680
1681 for (i = 0; i < kdamonds->nr; i++) {
1682 damon_sysfs_kdamond_rm_dirs(kdamonds_arr[i]);
1683 kobject_put(&kdamonds_arr[i]->kobj);
1684 }
1685 kdamonds->nr = 0;
1686 kfree(kdamonds_arr);
1687 kdamonds->kdamonds_arr = NULL;
1688 }
1689
1690 static bool damon_sysfs_kdamonds_busy(struct damon_sysfs_kdamond **kdamonds,
1691 int nr_kdamonds)
1692 {
1693 int i;
1694
1695 for (i = 0; i < nr_kdamonds; i++) {
1696 if (damon_sysfs_kdamond_running(kdamonds[i]) ||
1697 damon_sysfs_cmd_request.kdamond == kdamonds[i])
1698 return true;
1699 }
1700
1701 return false;
1702 }
1703
1704 static int damon_sysfs_kdamonds_add_dirs(struct damon_sysfs_kdamonds *kdamonds,
1705 int nr_kdamonds)
1706 {
1707 struct damon_sysfs_kdamond **kdamonds_arr, *kdamond;
1708 int err, i;
1709
1710 if (damon_sysfs_kdamonds_busy(kdamonds->kdamonds_arr, kdamonds->nr))
1711 return -EBUSY;
1712
1713 damon_sysfs_kdamonds_rm_dirs(kdamonds);
1714 if (!nr_kdamonds)
1715 return 0;
1716
1717 kdamonds_arr = kmalloc_array(nr_kdamonds, sizeof(*kdamonds_arr),
1718 GFP_KERNEL | __GFP_NOWARN);
1719 if (!kdamonds_arr)
1720 return -ENOMEM;
1721 kdamonds->kdamonds_arr = kdamonds_arr;
1722
1723 for (i = 0; i < nr_kdamonds; i++) {
1724 kdamond = damon_sysfs_kdamond_alloc();
1725 if (!kdamond) {
1726 damon_sysfs_kdamonds_rm_dirs(kdamonds);
1727 return -ENOMEM;
1728 }
1729
1730 err = kobject_init_and_add(&kdamond->kobj,
1731 &damon_sysfs_kdamond_ktype, &kdamonds->kobj,
1732 "%d", i);
1733 if (err)
1734 goto out;
1735
1736 err = damon_sysfs_kdamond_add_dirs(kdamond);
1737 if (err)
1738 goto out;
1739
1740 kdamonds_arr[i] = kdamond;
1741 kdamonds->nr++;
1742 }
1743 return 0;
1744
1745 out:
1746 damon_sysfs_kdamonds_rm_dirs(kdamonds);
1747 kobject_put(&kdamond->kobj);
1748 return err;
1749 }
1750
1751 static ssize_t nr_kdamonds_show(struct kobject *kobj,
1752 struct kobj_attribute *attr, char *buf)
1753 {
1754 struct damon_sysfs_kdamonds *kdamonds = container_of(kobj,
1755 struct damon_sysfs_kdamonds, kobj);
1756
1757 return sysfs_emit(buf, "%d\n", kdamonds->nr);
1758 }
1759
1760 static ssize_t nr_kdamonds_store(struct kobject *kobj,
1761 struct kobj_attribute *attr, const char *buf, size_t count)
1762 {
1763 struct damon_sysfs_kdamonds *kdamonds;
1764 int nr, err;
1765
1766 err = kstrtoint(buf, 0, &nr);
1767 if (err)
1768 return err;
1769 if (nr < 0)
1770 return -EINVAL;
1771
1772 kdamonds = container_of(kobj, struct damon_sysfs_kdamonds, kobj);
1773
1774 if (!mutex_trylock(&damon_sysfs_lock))
1775 return -EBUSY;
1776 err = damon_sysfs_kdamonds_add_dirs(kdamonds, nr);
1777 mutex_unlock(&damon_sysfs_lock);
1778 if (err)
1779 return err;
1780
1781 return count;
1782 }
1783
1784 static void damon_sysfs_kdamonds_release(struct kobject *kobj)
1785 {
1786 kfree(container_of(kobj, struct damon_sysfs_kdamonds, kobj));
1787 }
1788
1789 static struct kobj_attribute damon_sysfs_kdamonds_nr_attr =
1790 __ATTR_RW_MODE(nr_kdamonds, 0600);
1791
1792 static struct attribute *damon_sysfs_kdamonds_attrs[] = {
1793 &damon_sysfs_kdamonds_nr_attr.attr,
1794 NULL,
1795 };
1796 ATTRIBUTE_GROUPS(damon_sysfs_kdamonds);
1797
1798 static const struct kobj_type damon_sysfs_kdamonds_ktype = {
1799 .release = damon_sysfs_kdamonds_release,
1800 .sysfs_ops = &kobj_sysfs_ops,
1801 .default_groups = damon_sysfs_kdamonds_groups,
1802 };
1803
1804 /*
1805 * damon user interface directory
1806 */
1807
1808 struct damon_sysfs_ui_dir {
1809 struct kobject kobj;
1810 struct damon_sysfs_kdamonds *kdamonds;
1811 };
1812
1813 static struct damon_sysfs_ui_dir *damon_sysfs_ui_dir_alloc(void)
1814 {
1815 return kzalloc(sizeof(struct damon_sysfs_ui_dir), GFP_KERNEL);
1816 }
1817
1818 static int damon_sysfs_ui_dir_add_dirs(struct damon_sysfs_ui_dir *ui_dir)
1819 {
1820 struct damon_sysfs_kdamonds *kdamonds;
1821 int err;
1822
1823 kdamonds = damon_sysfs_kdamonds_alloc();
1824 if (!kdamonds)
1825 return -ENOMEM;
1826
1827 err = kobject_init_and_add(&kdamonds->kobj,
1828 &damon_sysfs_kdamonds_ktype, &ui_dir->kobj,
1829 "kdamonds");
1830 if (err) {
1831 kobject_put(&kdamonds->kobj);
1832 return err;
1833 }
1834 ui_dir->kdamonds = kdamonds;
1835 return err;
1836 }
1837
1838 static void damon_sysfs_ui_dir_release(struct kobject *kobj)
1839 {
1840 kfree(container_of(kobj, struct damon_sysfs_ui_dir, kobj));
1841 }
1842
1843 static struct attribute *damon_sysfs_ui_dir_attrs[] = {
1844 NULL,
1845 };
1846 ATTRIBUTE_GROUPS(damon_sysfs_ui_dir);
1847
1848 static const struct kobj_type damon_sysfs_ui_dir_ktype = {
1849 .release = damon_sysfs_ui_dir_release,
1850 .sysfs_ops = &kobj_sysfs_ops,
1851 .default_groups = damon_sysfs_ui_dir_groups,
1852 };
1853
1854 static int __init damon_sysfs_init(void)
1855 {
1856 struct kobject *damon_sysfs_root;
1857 struct damon_sysfs_ui_dir *admin;
1858 int err;
1859
1860 damon_sysfs_root = kobject_create_and_add("damon", mm_kobj);
1861 if (!damon_sysfs_root)
1862 return -ENOMEM;
1863
1864 admin = damon_sysfs_ui_dir_alloc();
1865 if (!admin) {
1866 kobject_put(damon_sysfs_root);
1867 return -ENOMEM;
1868 }
1869 err = kobject_init_and_add(&admin->kobj, &damon_sysfs_ui_dir_ktype,
1870 damon_sysfs_root, "admin");
1871 if (err)
1872 goto out;
1873 err = damon_sysfs_ui_dir_add_dirs(admin);
1874 if (err)
1875 goto out;
1876 return 0;
1877
1878 out:
1879 kobject_put(&admin->kobj);
1880 kobject_put(damon_sysfs_root);
1881 return err;
1882 }
1883 subsys_initcall(damon_sysfs_init);
1884
1885 #include "sysfs-test.h"
1886
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.