Loading...
Note: File does not exist in v5.9.
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
18struct damon_sysfs_region {
19 struct kobject kobj;
20 struct damon_addr_range ar;
21};
22
23static struct damon_sysfs_region *damon_sysfs_region_alloc(void)
24{
25 return kzalloc(sizeof(struct damon_sysfs_region), GFP_KERNEL);
26}
27
28static 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
37static 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
47static 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
56static 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
66static void damon_sysfs_region_release(struct kobject *kobj)
67{
68 kfree(container_of(kobj, struct damon_sysfs_region, kobj));
69}
70
71static struct kobj_attribute damon_sysfs_region_start_attr =
72 __ATTR_RW_MODE(start, 0600);
73
74static struct kobj_attribute damon_sysfs_region_end_attr =
75 __ATTR_RW_MODE(end, 0600);
76
77static struct attribute *damon_sysfs_region_attrs[] = {
78 &damon_sysfs_region_start_attr.attr,
79 &damon_sysfs_region_end_attr.attr,
80 NULL,
81};
82ATTRIBUTE_GROUPS(damon_sysfs_region);
83
84static 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
94struct damon_sysfs_regions {
95 struct kobject kobj;
96 struct damon_sysfs_region **regions_arr;
97 int nr;
98};
99
100static struct damon_sysfs_regions *damon_sysfs_regions_alloc(void)
101{
102 return kzalloc(sizeof(struct damon_sysfs_regions), GFP_KERNEL);
103}
104
105static 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
117static 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
155static 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
164static 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
187static void damon_sysfs_regions_release(struct kobject *kobj)
188{
189 kfree(container_of(kobj, struct damon_sysfs_regions, kobj));
190}
191
192static struct kobj_attribute damon_sysfs_regions_nr_attr =
193 __ATTR_RW_MODE(nr_regions, 0600);
194
195static struct attribute *damon_sysfs_regions_attrs[] = {
196 &damon_sysfs_regions_nr_attr.attr,
197 NULL,
198};
199ATTRIBUTE_GROUPS(damon_sysfs_regions);
200
201static 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
211struct damon_sysfs_target {
212 struct kobject kobj;
213 struct damon_sysfs_regions *regions;
214 int pid;
215};
216
217static struct damon_sysfs_target *damon_sysfs_target_alloc(void)
218{
219 return kzalloc(sizeof(struct damon_sysfs_target), GFP_KERNEL);
220}
221
222static 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
239static 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
245static 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
254static 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
266static void damon_sysfs_target_release(struct kobject *kobj)
267{
268 kfree(container_of(kobj, struct damon_sysfs_target, kobj));
269}
270
271static struct kobj_attribute damon_sysfs_target_pid_attr =
272 __ATTR_RW_MODE(pid_target, 0600);
273
274static struct attribute *damon_sysfs_target_attrs[] = {
275 &damon_sysfs_target_pid_attr.attr,
276 NULL,
277};
278ATTRIBUTE_GROUPS(damon_sysfs_target);
279
280static 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
290struct damon_sysfs_targets {
291 struct kobject kobj;
292 struct damon_sysfs_target **targets_arr;
293 int nr;
294};
295
296static struct damon_sysfs_targets *damon_sysfs_targets_alloc(void)
297{
298 return kzalloc(sizeof(struct damon_sysfs_targets), GFP_KERNEL);
299}
300
301static 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
315static 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
353out:
354 damon_sysfs_targets_rm_dirs(targets);
355 kobject_put(&target->kobj);
356 return err;
357}
358
359static 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
368static 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
391static void damon_sysfs_targets_release(struct kobject *kobj)
392{
393 kfree(container_of(kobj, struct damon_sysfs_targets, kobj));
394}
395
396static struct kobj_attribute damon_sysfs_targets_nr_attr =
397 __ATTR_RW_MODE(nr_targets, 0600);
398
399static struct attribute *damon_sysfs_targets_attrs[] = {
400 &damon_sysfs_targets_nr_attr.attr,
401 NULL,
402};
403ATTRIBUTE_GROUPS(damon_sysfs_targets);
404
405static 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
415struct damon_sysfs_intervals {
416 struct kobject kobj;
417 unsigned long sample_us;
418 unsigned long aggr_us;
419 unsigned long update_us;
420};
421
422static 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
439static 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
448static 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
463static 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
472static 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
487static 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
496static 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
511static void damon_sysfs_intervals_release(struct kobject *kobj)
512{
513 kfree(container_of(kobj, struct damon_sysfs_intervals, kobj));
514}
515
516static struct kobj_attribute damon_sysfs_intervals_sample_us_attr =
517 __ATTR_RW_MODE(sample_us, 0600);
518
519static struct kobj_attribute damon_sysfs_intervals_aggr_us_attr =
520 __ATTR_RW_MODE(aggr_us, 0600);
521
522static struct kobj_attribute damon_sysfs_intervals_update_us_attr =
523 __ATTR_RW_MODE(update_us, 0600);
524
525static 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};
531ATTRIBUTE_GROUPS(damon_sysfs_intervals);
532
533static 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
543struct damon_sysfs_attrs {
544 struct kobject kobj;
545 struct damon_sysfs_intervals *intervals;
546 struct damon_sysfs_ul_range *nr_regions_range;
547};
548
549static 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
559static 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
590put_nr_regions_intervals_out:
591 kobject_put(&nr_regions_range->kobj);
592 attrs->nr_regions_range = NULL;
593put_intervals_out:
594 kobject_put(&intervals->kobj);
595 attrs->intervals = NULL;
596 return err;
597}
598
599static 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
605static void damon_sysfs_attrs_release(struct kobject *kobj)
606{
607 kfree(container_of(kobj, struct damon_sysfs_attrs, kobj));
608}
609
610static struct attribute *damon_sysfs_attrs_attrs[] = {
611 NULL,
612};
613ATTRIBUTE_GROUPS(damon_sysfs_attrs);
614
615static 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 */
626static const char * const damon_sysfs_ops_strs[] = {
627 "vaddr",
628 "fvaddr",
629 "paddr",
630};
631
632struct 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
640static 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
653static 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
670out:
671 kobject_put(&attrs->kobj);
672 return err;
673}
674
675static 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
692static 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
709static 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
726put_targets_attrs_out:
727 kobject_put(&context->targets->kobj);
728 context->targets = NULL;
729put_attrs_out:
730 kobject_put(&context->attrs->kobj);
731 context->attrs = NULL;
732 return err;
733}
734
735static 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
745static 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
760static 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
769static 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
785static void damon_sysfs_context_release(struct kobject *kobj)
786{
787 kfree(container_of(kobj, struct damon_sysfs_context, kobj));
788}
789
790static struct kobj_attribute damon_sysfs_context_avail_operations_attr =
791 __ATTR_RO_MODE(avail_operations, 0400);
792
793static struct kobj_attribute damon_sysfs_context_operations_attr =
794 __ATTR_RW_MODE(operations, 0600);
795
796static struct attribute *damon_sysfs_context_attrs[] = {
797 &damon_sysfs_context_avail_operations_attr.attr,
798 &damon_sysfs_context_operations_attr.attr,
799 NULL,
800};
801ATTRIBUTE_GROUPS(damon_sysfs_context);
802
803static 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
813struct damon_sysfs_contexts {
814 struct kobject kobj;
815 struct damon_sysfs_context **contexts_arr;
816 int nr;
817};
818
819static struct damon_sysfs_contexts *damon_sysfs_contexts_alloc(void)
820{
821 return kzalloc(sizeof(struct damon_sysfs_contexts), GFP_KERNEL);
822}
823
824static 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
838static 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
876out:
877 damon_sysfs_contexts_rm_dirs(contexts);
878 kobject_put(&context->kobj);
879 return err;
880}
881
882static 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
891static 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
915static void damon_sysfs_contexts_release(struct kobject *kobj)
916{
917 kfree(container_of(kobj, struct damon_sysfs_contexts, kobj));
918}
919
920static struct kobj_attribute damon_sysfs_contexts_nr_attr
921 = __ATTR_RW_MODE(nr_contexts, 0600);
922
923static struct attribute *damon_sysfs_contexts_attrs[] = {
924 &damon_sysfs_contexts_nr_attr.attr,
925 NULL,
926};
927ATTRIBUTE_GROUPS(damon_sysfs_contexts);
928
929static 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
939struct damon_sysfs_kdamond {
940 struct kobject kobj;
941 struct damon_sysfs_contexts *contexts;
942 struct damon_ctx *damon_ctx;
943};
944
945static struct damon_sysfs_kdamond *damon_sysfs_kdamond_alloc(void)
946{
947 return kzalloc(sizeof(struct damon_sysfs_kdamond), GFP_KERNEL);
948}
949
950static 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
971static 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
977static 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 */
990enum 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 */
1034static 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 */
1057struct 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. */
1063static struct damon_sysfs_cmd_request damon_sysfs_cmd_request;
1064
1065static 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
1083static 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
1099static 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
1111static 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);
1135out:
1136 kfree(ranges);
1137 return err;
1138
1139}
1140
1141static 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
1160destroy_targets_out:
1161 damon_sysfs_destroy_targets(ctx);
1162 return err;
1163}
1164
1165static int damon_sysfs_update_target_pid(struct damon_target *target, int pid)
1166{
1167 struct pid *pid_new;
1168
1169 pid_new = find_get_pid(pid);
1170 if (!pid_new)
1171 return -EINVAL;
1172
1173 if (pid_new == target->pid) {
1174 put_pid(pid_new);
1175 return 0;
1176 }
1177
1178 put_pid(target->pid);
1179 target->pid = pid_new;
1180 return 0;
1181}
1182
1183static int damon_sysfs_update_target(struct damon_target *target,
1184 struct damon_ctx *ctx,
1185 struct damon_sysfs_target *sys_target)
1186{
1187 int err = 0;
1188
1189 if (damon_target_has_pid(ctx)) {
1190 err = damon_sysfs_update_target_pid(target, sys_target->pid);
1191 if (err)
1192 return err;
1193 }
1194
1195 /*
1196 * Do monitoring target region boundary update only if one or more
1197 * regions are set by the user. This is for keeping current monitoring
1198 * target results and range easier, especially for dynamic monitoring
1199 * target regions update ops like 'vaddr'.
1200 */
1201 if (sys_target->regions->nr)
1202 err = damon_sysfs_set_regions(target, sys_target->regions);
1203 return err;
1204}
1205
1206static int damon_sysfs_set_targets(struct damon_ctx *ctx,
1207 struct damon_sysfs_targets *sysfs_targets)
1208{
1209 struct damon_target *t, *next;
1210 int i = 0, err;
1211
1212 /* Multiple physical address space monitoring targets makes no sense */
1213 if (ctx->ops.id == DAMON_OPS_PADDR && sysfs_targets->nr > 1)
1214 return -EINVAL;
1215
1216 damon_for_each_target_safe(t, next, ctx) {
1217 if (i < sysfs_targets->nr) {
1218 err = damon_sysfs_update_target(t, ctx,
1219 sysfs_targets->targets_arr[i]);
1220 if (err)
1221 return err;
1222 } else {
1223 if (damon_target_has_pid(ctx))
1224 put_pid(t->pid);
1225 damon_destroy_target(t);
1226 }
1227 i++;
1228 }
1229
1230 for (; i < sysfs_targets->nr; i++) {
1231 struct damon_sysfs_target *st = sysfs_targets->targets_arr[i];
1232
1233 err = damon_sysfs_add_target(st, ctx);
1234 if (err)
1235 return err;
1236 }
1237 return 0;
1238}
1239
1240static bool damon_sysfs_schemes_regions_updating;
1241
1242static void damon_sysfs_before_terminate(struct damon_ctx *ctx)
1243{
1244 struct damon_target *t, *next;
1245 struct damon_sysfs_kdamond *kdamond;
1246 enum damon_sysfs_cmd cmd;
1247
1248 /* damon_sysfs_schemes_update_regions_stop() might not yet called */
1249 kdamond = damon_sysfs_cmd_request.kdamond;
1250 cmd = damon_sysfs_cmd_request.cmd;
1251 if (kdamond && ctx == kdamond->damon_ctx &&
1252 (cmd == DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS ||
1253 cmd == DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES) &&
1254 damon_sysfs_schemes_regions_updating) {
1255 damon_sysfs_schemes_update_regions_stop(ctx);
1256 damon_sysfs_schemes_regions_updating = false;
1257 mutex_unlock(&damon_sysfs_lock);
1258 }
1259
1260 if (!damon_target_has_pid(ctx))
1261 return;
1262
1263 mutex_lock(&ctx->kdamond_lock);
1264 damon_for_each_target_safe(t, next, ctx) {
1265 put_pid(t->pid);
1266 damon_destroy_target(t);
1267 }
1268 mutex_unlock(&ctx->kdamond_lock);
1269}
1270
1271/*
1272 * damon_sysfs_upd_schemes_stats() - Update schemes stats sysfs files.
1273 * @kdamond: The kobject wrapper that associated to the kdamond thread.
1274 *
1275 * This function reads the schemes stats of specific kdamond and update the
1276 * related values for sysfs files. This function should be called from DAMON
1277 * callbacks while holding ``damon_syfs_lock``, to safely access the DAMON
1278 * contexts-internal data and DAMON sysfs variables.
1279 */
1280static int damon_sysfs_upd_schemes_stats(struct damon_sysfs_kdamond *kdamond)
1281{
1282 struct damon_ctx *ctx = kdamond->damon_ctx;
1283
1284 if (!ctx)
1285 return -EINVAL;
1286 damon_sysfs_schemes_update_stats(
1287 kdamond->contexts->contexts_arr[0]->schemes, ctx);
1288 return 0;
1289}
1290
1291static int damon_sysfs_upd_schemes_regions_start(
1292 struct damon_sysfs_kdamond *kdamond, bool total_bytes_only)
1293{
1294 struct damon_ctx *ctx = kdamond->damon_ctx;
1295
1296 if (!ctx)
1297 return -EINVAL;
1298 return damon_sysfs_schemes_update_regions_start(
1299 kdamond->contexts->contexts_arr[0]->schemes, ctx,
1300 total_bytes_only);
1301}
1302
1303static int damon_sysfs_upd_schemes_regions_stop(
1304 struct damon_sysfs_kdamond *kdamond)
1305{
1306 struct damon_ctx *ctx = kdamond->damon_ctx;
1307
1308 if (!ctx)
1309 return -EINVAL;
1310 return damon_sysfs_schemes_update_regions_stop(ctx);
1311}
1312
1313static int damon_sysfs_clear_schemes_regions(
1314 struct damon_sysfs_kdamond *kdamond)
1315{
1316 struct damon_ctx *ctx = kdamond->damon_ctx;
1317
1318 if (!ctx)
1319 return -EINVAL;
1320 return damon_sysfs_schemes_clear_regions(
1321 kdamond->contexts->contexts_arr[0]->schemes, ctx);
1322}
1323
1324static inline bool damon_sysfs_kdamond_running(
1325 struct damon_sysfs_kdamond *kdamond)
1326{
1327 return kdamond->damon_ctx &&
1328 damon_sysfs_ctx_running(kdamond->damon_ctx);
1329}
1330
1331static int damon_sysfs_apply_inputs(struct damon_ctx *ctx,
1332 struct damon_sysfs_context *sys_ctx)
1333{
1334 int err;
1335
1336 err = damon_select_ops(ctx, sys_ctx->ops_id);
1337 if (err)
1338 return err;
1339 err = damon_sysfs_set_attrs(ctx, sys_ctx->attrs);
1340 if (err)
1341 return err;
1342 err = damon_sysfs_set_targets(ctx, sys_ctx->targets);
1343 if (err)
1344 return err;
1345 return damon_sysfs_set_schemes(ctx, sys_ctx->schemes);
1346}
1347
1348/*
1349 * damon_sysfs_commit_input() - Commit user inputs to a running kdamond.
1350 * @kdamond: The kobject wrapper for the associated kdamond.
1351 *
1352 * If the sysfs input is wrong, the kdamond will be terminated.
1353 */
1354static int damon_sysfs_commit_input(struct damon_sysfs_kdamond *kdamond)
1355{
1356 if (!damon_sysfs_kdamond_running(kdamond))
1357 return -EINVAL;
1358 /* TODO: Support multiple contexts per kdamond */
1359 if (kdamond->contexts->nr != 1)
1360 return -EINVAL;
1361
1362 return damon_sysfs_apply_inputs(kdamond->damon_ctx,
1363 kdamond->contexts->contexts_arr[0]);
1364}
1365
1366static int damon_sysfs_commit_schemes_quota_goals(
1367 struct damon_sysfs_kdamond *sysfs_kdamond)
1368{
1369 struct damon_ctx *ctx;
1370 struct damon_sysfs_context *sysfs_ctx;
1371
1372 if (!damon_sysfs_kdamond_running(sysfs_kdamond))
1373 return -EINVAL;
1374 /* TODO: Support multiple contexts per kdamond */
1375 if (sysfs_kdamond->contexts->nr != 1)
1376 return -EINVAL;
1377
1378 ctx = sysfs_kdamond->damon_ctx;
1379 sysfs_ctx = sysfs_kdamond->contexts->contexts_arr[0];
1380 return damos_sysfs_set_quota_scores(sysfs_ctx->schemes, ctx);
1381}
1382
1383/*
1384 * damon_sysfs_upd_schemes_effective_quotas() - Update schemes effective quotas
1385 * sysfs files.
1386 * @kdamond: The kobject wrapper that associated to the kdamond thread.
1387 *
1388 * This function reads the schemes' effective quotas of specific kdamond and
1389 * update the related values for sysfs files. This function should be called
1390 * from DAMON callbacks while holding ``damon_syfs_lock``, to safely access the
1391 * DAMON contexts-internal data and DAMON sysfs variables.
1392 */
1393static int damon_sysfs_upd_schemes_effective_quotas(
1394 struct damon_sysfs_kdamond *kdamond)
1395{
1396 struct damon_ctx *ctx = kdamond->damon_ctx;
1397
1398 if (!ctx)
1399 return -EINVAL;
1400 damos_sysfs_update_effective_quotas(
1401 kdamond->contexts->contexts_arr[0]->schemes, ctx);
1402 return 0;
1403}
1404
1405
1406/*
1407 * damon_sysfs_cmd_request_callback() - DAMON callback for handling requests.
1408 * @c: The DAMON context of the callback.
1409 * @active: Whether @c is not deactivated due to watermarks.
1410 * @after_aggr: Whether this is called from after_aggregation() callback.
1411 *
1412 * This function is periodically called back from the kdamond thread for @c.
1413 * Then, it checks if there is a waiting DAMON sysfs request and handles it.
1414 */
1415static int damon_sysfs_cmd_request_callback(struct damon_ctx *c, bool active,
1416 bool after_aggregation)
1417{
1418 struct damon_sysfs_kdamond *kdamond;
1419 bool total_bytes_only = false;
1420 int err = 0;
1421
1422 /* avoid deadlock due to concurrent state_store('off') */
1423 if (!damon_sysfs_schemes_regions_updating &&
1424 !mutex_trylock(&damon_sysfs_lock))
1425 return 0;
1426 kdamond = damon_sysfs_cmd_request.kdamond;
1427 if (!kdamond || kdamond->damon_ctx != c)
1428 goto out;
1429 switch (damon_sysfs_cmd_request.cmd) {
1430 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS:
1431 err = damon_sysfs_upd_schemes_stats(kdamond);
1432 break;
1433 case DAMON_SYSFS_CMD_COMMIT:
1434 if (!after_aggregation)
1435 goto out;
1436 err = damon_sysfs_commit_input(kdamond);
1437 break;
1438 case DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS:
1439 err = damon_sysfs_commit_schemes_quota_goals(kdamond);
1440 break;
1441 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES:
1442 total_bytes_only = true;
1443 fallthrough;
1444 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS:
1445 if (!damon_sysfs_schemes_regions_updating) {
1446 err = damon_sysfs_upd_schemes_regions_start(kdamond,
1447 total_bytes_only);
1448 if (!err) {
1449 damon_sysfs_schemes_regions_updating = true;
1450 goto keep_lock_out;
1451 }
1452 } else {
1453 damos_sysfs_mark_finished_regions_updates(c);
1454 /*
1455 * Continue regions updating if DAMON is till
1456 * active and the update for all schemes is not
1457 * finished.
1458 */
1459 if (active && !damos_sysfs_regions_upd_done())
1460 goto keep_lock_out;
1461 err = damon_sysfs_upd_schemes_regions_stop(kdamond);
1462 damon_sysfs_schemes_regions_updating = false;
1463 }
1464 break;
1465 case DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS:
1466 err = damon_sysfs_clear_schemes_regions(kdamond);
1467 break;
1468 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS:
1469 err = damon_sysfs_upd_schemes_effective_quotas(kdamond);
1470 break;
1471 default:
1472 break;
1473 }
1474 /* Mark the request as invalid now. */
1475 damon_sysfs_cmd_request.kdamond = NULL;
1476out:
1477 if (!damon_sysfs_schemes_regions_updating)
1478 mutex_unlock(&damon_sysfs_lock);
1479keep_lock_out:
1480 return err;
1481}
1482
1483static int damon_sysfs_after_wmarks_check(struct damon_ctx *c)
1484{
1485 /*
1486 * after_wmarks_check() is called back while the context is deactivated
1487 * by watermarks.
1488 */
1489 return damon_sysfs_cmd_request_callback(c, false, false);
1490}
1491
1492static int damon_sysfs_after_sampling(struct damon_ctx *c)
1493{
1494 /*
1495 * after_sampling() is called back only while the context is not
1496 * deactivated by watermarks.
1497 */
1498 return damon_sysfs_cmd_request_callback(c, true, false);
1499}
1500
1501static int damon_sysfs_after_aggregation(struct damon_ctx *c)
1502{
1503 /*
1504 * after_aggregation() is called back only while the context is not
1505 * deactivated by watermarks.
1506 */
1507 return damon_sysfs_cmd_request_callback(c, true, true);
1508}
1509
1510static struct damon_ctx *damon_sysfs_build_ctx(
1511 struct damon_sysfs_context *sys_ctx)
1512{
1513 struct damon_ctx *ctx = damon_new_ctx();
1514 int err;
1515
1516 if (!ctx)
1517 return ERR_PTR(-ENOMEM);
1518
1519 err = damon_sysfs_apply_inputs(ctx, sys_ctx);
1520 if (err) {
1521 damon_destroy_ctx(ctx);
1522 return ERR_PTR(err);
1523 }
1524
1525 ctx->callback.after_wmarks_check = damon_sysfs_after_wmarks_check;
1526 ctx->callback.after_sampling = damon_sysfs_after_sampling;
1527 ctx->callback.after_aggregation = damon_sysfs_after_aggregation;
1528 ctx->callback.before_terminate = damon_sysfs_before_terminate;
1529 return ctx;
1530}
1531
1532static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond)
1533{
1534 struct damon_ctx *ctx;
1535 int err;
1536
1537 if (damon_sysfs_kdamond_running(kdamond))
1538 return -EBUSY;
1539 if (damon_sysfs_cmd_request.kdamond == kdamond)
1540 return -EBUSY;
1541 /* TODO: support multiple contexts per kdamond */
1542 if (kdamond->contexts->nr != 1)
1543 return -EINVAL;
1544
1545 if (kdamond->damon_ctx)
1546 damon_destroy_ctx(kdamond->damon_ctx);
1547 kdamond->damon_ctx = NULL;
1548
1549 ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]);
1550 if (IS_ERR(ctx))
1551 return PTR_ERR(ctx);
1552 err = damon_start(&ctx, 1, false);
1553 if (err) {
1554 damon_destroy_ctx(ctx);
1555 return err;
1556 }
1557 kdamond->damon_ctx = ctx;
1558 return err;
1559}
1560
1561static int damon_sysfs_turn_damon_off(struct damon_sysfs_kdamond *kdamond)
1562{
1563 if (!kdamond->damon_ctx)
1564 return -EINVAL;
1565 return damon_stop(&kdamond->damon_ctx, 1);
1566 /*
1567 * To allow users show final monitoring results of already turned-off
1568 * DAMON, we free kdamond->damon_ctx in next
1569 * damon_sysfs_turn_damon_on(), or kdamonds_nr_store()
1570 */
1571}
1572
1573/*
1574 * damon_sysfs_handle_cmd() - Handle a command for a specific kdamond.
1575 * @cmd: The command to handle.
1576 * @kdamond: The kobject wrapper for the associated kdamond.
1577 *
1578 * This function handles a DAMON sysfs command for a kdamond. For commands
1579 * that need to access running DAMON context-internal data, it requests
1580 * handling of the command to the DAMON callback
1581 * (@damon_sysfs_cmd_request_callback()) and wait until it is properly handled,
1582 * or the context is completed.
1583 *
1584 * Return: 0 on success, negative error code otherwise.
1585 */
1586static int damon_sysfs_handle_cmd(enum damon_sysfs_cmd cmd,
1587 struct damon_sysfs_kdamond *kdamond)
1588{
1589 bool need_wait = true;
1590
1591 /* Handle commands that doesn't access DAMON context-internal data */
1592 switch (cmd) {
1593 case DAMON_SYSFS_CMD_ON:
1594 return damon_sysfs_turn_damon_on(kdamond);
1595 case DAMON_SYSFS_CMD_OFF:
1596 return damon_sysfs_turn_damon_off(kdamond);
1597 default:
1598 break;
1599 }
1600
1601 /* Pass the command to DAMON callback for safe DAMON context access */
1602 if (damon_sysfs_cmd_request.kdamond)
1603 return -EBUSY;
1604 if (!damon_sysfs_kdamond_running(kdamond))
1605 return -EINVAL;
1606 damon_sysfs_cmd_request.cmd = cmd;
1607 damon_sysfs_cmd_request.kdamond = kdamond;
1608
1609 /*
1610 * wait until damon_sysfs_cmd_request_callback() handles the request
1611 * from kdamond context
1612 */
1613 mutex_unlock(&damon_sysfs_lock);
1614 while (need_wait) {
1615 schedule_timeout_idle(msecs_to_jiffies(100));
1616 if (!mutex_trylock(&damon_sysfs_lock))
1617 continue;
1618 if (!damon_sysfs_cmd_request.kdamond) {
1619 /* damon_sysfs_cmd_request_callback() handled */
1620 need_wait = false;
1621 } else if (!damon_sysfs_kdamond_running(kdamond)) {
1622 /* kdamond has already finished */
1623 need_wait = false;
1624 damon_sysfs_cmd_request.kdamond = NULL;
1625 }
1626 mutex_unlock(&damon_sysfs_lock);
1627 }
1628 mutex_lock(&damon_sysfs_lock);
1629 return 0;
1630}
1631
1632static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
1633 const char *buf, size_t count)
1634{
1635 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1636 struct damon_sysfs_kdamond, kobj);
1637 enum damon_sysfs_cmd cmd;
1638 ssize_t ret = -EINVAL;
1639
1640 if (!mutex_trylock(&damon_sysfs_lock))
1641 return -EBUSY;
1642 for (cmd = 0; cmd < NR_DAMON_SYSFS_CMDS; cmd++) {
1643 if (sysfs_streq(buf, damon_sysfs_cmd_strs[cmd])) {
1644 ret = damon_sysfs_handle_cmd(cmd, kdamond);
1645 break;
1646 }
1647 }
1648 mutex_unlock(&damon_sysfs_lock);
1649 if (!ret)
1650 ret = count;
1651 return ret;
1652}
1653
1654static ssize_t pid_show(struct kobject *kobj,
1655 struct kobj_attribute *attr, char *buf)
1656{
1657 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1658 struct damon_sysfs_kdamond, kobj);
1659 struct damon_ctx *ctx;
1660 int pid = -1;
1661
1662 if (!mutex_trylock(&damon_sysfs_lock))
1663 return -EBUSY;
1664 ctx = kdamond->damon_ctx;
1665 if (!ctx)
1666 goto out;
1667
1668 mutex_lock(&ctx->kdamond_lock);
1669 if (ctx->kdamond)
1670 pid = ctx->kdamond->pid;
1671 mutex_unlock(&ctx->kdamond_lock);
1672out:
1673 mutex_unlock(&damon_sysfs_lock);
1674 return sysfs_emit(buf, "%d\n", pid);
1675}
1676
1677static void damon_sysfs_kdamond_release(struct kobject *kobj)
1678{
1679 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1680 struct damon_sysfs_kdamond, kobj);
1681
1682 if (kdamond->damon_ctx)
1683 damon_destroy_ctx(kdamond->damon_ctx);
1684 kfree(kdamond);
1685}
1686
1687static struct kobj_attribute damon_sysfs_kdamond_state_attr =
1688 __ATTR_RW_MODE(state, 0600);
1689
1690static struct kobj_attribute damon_sysfs_kdamond_pid_attr =
1691 __ATTR_RO_MODE(pid, 0400);
1692
1693static struct attribute *damon_sysfs_kdamond_attrs[] = {
1694 &damon_sysfs_kdamond_state_attr.attr,
1695 &damon_sysfs_kdamond_pid_attr.attr,
1696 NULL,
1697};
1698ATTRIBUTE_GROUPS(damon_sysfs_kdamond);
1699
1700static const struct kobj_type damon_sysfs_kdamond_ktype = {
1701 .release = damon_sysfs_kdamond_release,
1702 .sysfs_ops = &kobj_sysfs_ops,
1703 .default_groups = damon_sysfs_kdamond_groups,
1704};
1705
1706/*
1707 * kdamonds directory
1708 */
1709
1710struct damon_sysfs_kdamonds {
1711 struct kobject kobj;
1712 struct damon_sysfs_kdamond **kdamonds_arr;
1713 int nr;
1714};
1715
1716static struct damon_sysfs_kdamonds *damon_sysfs_kdamonds_alloc(void)
1717{
1718 return kzalloc(sizeof(struct damon_sysfs_kdamonds), GFP_KERNEL);
1719}
1720
1721static void damon_sysfs_kdamonds_rm_dirs(struct damon_sysfs_kdamonds *kdamonds)
1722{
1723 struct damon_sysfs_kdamond **kdamonds_arr = kdamonds->kdamonds_arr;
1724 int i;
1725
1726 for (i = 0; i < kdamonds->nr; i++) {
1727 damon_sysfs_kdamond_rm_dirs(kdamonds_arr[i]);
1728 kobject_put(&kdamonds_arr[i]->kobj);
1729 }
1730 kdamonds->nr = 0;
1731 kfree(kdamonds_arr);
1732 kdamonds->kdamonds_arr = NULL;
1733}
1734
1735static bool damon_sysfs_kdamonds_busy(struct damon_sysfs_kdamond **kdamonds,
1736 int nr_kdamonds)
1737{
1738 int i;
1739
1740 for (i = 0; i < nr_kdamonds; i++) {
1741 if (damon_sysfs_kdamond_running(kdamonds[i]) ||
1742 damon_sysfs_cmd_request.kdamond == kdamonds[i])
1743 return true;
1744 }
1745
1746 return false;
1747}
1748
1749static int damon_sysfs_kdamonds_add_dirs(struct damon_sysfs_kdamonds *kdamonds,
1750 int nr_kdamonds)
1751{
1752 struct damon_sysfs_kdamond **kdamonds_arr, *kdamond;
1753 int err, i;
1754
1755 if (damon_sysfs_kdamonds_busy(kdamonds->kdamonds_arr, kdamonds->nr))
1756 return -EBUSY;
1757
1758 damon_sysfs_kdamonds_rm_dirs(kdamonds);
1759 if (!nr_kdamonds)
1760 return 0;
1761
1762 kdamonds_arr = kmalloc_array(nr_kdamonds, sizeof(*kdamonds_arr),
1763 GFP_KERNEL | __GFP_NOWARN);
1764 if (!kdamonds_arr)
1765 return -ENOMEM;
1766 kdamonds->kdamonds_arr = kdamonds_arr;
1767
1768 for (i = 0; i < nr_kdamonds; i++) {
1769 kdamond = damon_sysfs_kdamond_alloc();
1770 if (!kdamond) {
1771 damon_sysfs_kdamonds_rm_dirs(kdamonds);
1772 return -ENOMEM;
1773 }
1774
1775 err = kobject_init_and_add(&kdamond->kobj,
1776 &damon_sysfs_kdamond_ktype, &kdamonds->kobj,
1777 "%d", i);
1778 if (err)
1779 goto out;
1780
1781 err = damon_sysfs_kdamond_add_dirs(kdamond);
1782 if (err)
1783 goto out;
1784
1785 kdamonds_arr[i] = kdamond;
1786 kdamonds->nr++;
1787 }
1788 return 0;
1789
1790out:
1791 damon_sysfs_kdamonds_rm_dirs(kdamonds);
1792 kobject_put(&kdamond->kobj);
1793 return err;
1794}
1795
1796static ssize_t nr_kdamonds_show(struct kobject *kobj,
1797 struct kobj_attribute *attr, char *buf)
1798{
1799 struct damon_sysfs_kdamonds *kdamonds = container_of(kobj,
1800 struct damon_sysfs_kdamonds, kobj);
1801
1802 return sysfs_emit(buf, "%d\n", kdamonds->nr);
1803}
1804
1805static ssize_t nr_kdamonds_store(struct kobject *kobj,
1806 struct kobj_attribute *attr, const char *buf, size_t count)
1807{
1808 struct damon_sysfs_kdamonds *kdamonds;
1809 int nr, err;
1810
1811 err = kstrtoint(buf, 0, &nr);
1812 if (err)
1813 return err;
1814 if (nr < 0)
1815 return -EINVAL;
1816
1817 kdamonds = container_of(kobj, struct damon_sysfs_kdamonds, kobj);
1818
1819 if (!mutex_trylock(&damon_sysfs_lock))
1820 return -EBUSY;
1821 err = damon_sysfs_kdamonds_add_dirs(kdamonds, nr);
1822 mutex_unlock(&damon_sysfs_lock);
1823 if (err)
1824 return err;
1825
1826 return count;
1827}
1828
1829static void damon_sysfs_kdamonds_release(struct kobject *kobj)
1830{
1831 kfree(container_of(kobj, struct damon_sysfs_kdamonds, kobj));
1832}
1833
1834static struct kobj_attribute damon_sysfs_kdamonds_nr_attr =
1835 __ATTR_RW_MODE(nr_kdamonds, 0600);
1836
1837static struct attribute *damon_sysfs_kdamonds_attrs[] = {
1838 &damon_sysfs_kdamonds_nr_attr.attr,
1839 NULL,
1840};
1841ATTRIBUTE_GROUPS(damon_sysfs_kdamonds);
1842
1843static const struct kobj_type damon_sysfs_kdamonds_ktype = {
1844 .release = damon_sysfs_kdamonds_release,
1845 .sysfs_ops = &kobj_sysfs_ops,
1846 .default_groups = damon_sysfs_kdamonds_groups,
1847};
1848
1849/*
1850 * damon user interface directory
1851 */
1852
1853struct damon_sysfs_ui_dir {
1854 struct kobject kobj;
1855 struct damon_sysfs_kdamonds *kdamonds;
1856};
1857
1858static struct damon_sysfs_ui_dir *damon_sysfs_ui_dir_alloc(void)
1859{
1860 return kzalloc(sizeof(struct damon_sysfs_ui_dir), GFP_KERNEL);
1861}
1862
1863static int damon_sysfs_ui_dir_add_dirs(struct damon_sysfs_ui_dir *ui_dir)
1864{
1865 struct damon_sysfs_kdamonds *kdamonds;
1866 int err;
1867
1868 kdamonds = damon_sysfs_kdamonds_alloc();
1869 if (!kdamonds)
1870 return -ENOMEM;
1871
1872 err = kobject_init_and_add(&kdamonds->kobj,
1873 &damon_sysfs_kdamonds_ktype, &ui_dir->kobj,
1874 "kdamonds");
1875 if (err) {
1876 kobject_put(&kdamonds->kobj);
1877 return err;
1878 }
1879 ui_dir->kdamonds = kdamonds;
1880 return err;
1881}
1882
1883static void damon_sysfs_ui_dir_release(struct kobject *kobj)
1884{
1885 kfree(container_of(kobj, struct damon_sysfs_ui_dir, kobj));
1886}
1887
1888static struct attribute *damon_sysfs_ui_dir_attrs[] = {
1889 NULL,
1890};
1891ATTRIBUTE_GROUPS(damon_sysfs_ui_dir);
1892
1893static const struct kobj_type damon_sysfs_ui_dir_ktype = {
1894 .release = damon_sysfs_ui_dir_release,
1895 .sysfs_ops = &kobj_sysfs_ops,
1896 .default_groups = damon_sysfs_ui_dir_groups,
1897};
1898
1899static int __init damon_sysfs_init(void)
1900{
1901 struct kobject *damon_sysfs_root;
1902 struct damon_sysfs_ui_dir *admin;
1903 int err;
1904
1905 damon_sysfs_root = kobject_create_and_add("damon", mm_kobj);
1906 if (!damon_sysfs_root)
1907 return -ENOMEM;
1908
1909 admin = damon_sysfs_ui_dir_alloc();
1910 if (!admin) {
1911 kobject_put(damon_sysfs_root);
1912 return -ENOMEM;
1913 }
1914 err = kobject_init_and_add(&admin->kobj, &damon_sysfs_ui_dir_ktype,
1915 damon_sysfs_root, "admin");
1916 if (err)
1917 goto out;
1918 err = damon_sysfs_ui_dir_add_dirs(admin);
1919 if (err)
1920 goto out;
1921 return 0;
1922
1923out:
1924 kobject_put(&admin->kobj);
1925 kobject_put(damon_sysfs_root);
1926 return err;
1927}
1928subsys_initcall(damon_sysfs_init);
1929
1930#include "sysfs-test.h"