Loading...
Note: File does not exist in v5.4.
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 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 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 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 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 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 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 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 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_UPDATE_SCHEMES_STATS: Update scheme stats sysfs
999 * files.
1000 */
1001 DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS,
1002 /*
1003 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS: Update schemes tried
1004 * regions
1005 */
1006 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS,
1007 /*
1008 * @DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS: Clear schemes tried
1009 * regions
1010 */
1011 DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS,
1012 /*
1013 * @NR_DAMON_SYSFS_CMDS: Total number of DAMON sysfs commands.
1014 */
1015 NR_DAMON_SYSFS_CMDS,
1016};
1017
1018/* Should match with enum damon_sysfs_cmd */
1019static const char * const damon_sysfs_cmd_strs[] = {
1020 "on",
1021 "off",
1022 "commit",
1023 "update_schemes_stats",
1024 "update_schemes_tried_regions",
1025 "clear_schemes_tried_regions",
1026};
1027
1028/*
1029 * struct damon_sysfs_cmd_request - A request to the DAMON callback.
1030 * @cmd: The command that needs to be handled by the callback.
1031 * @kdamond: The kobject wrapper that associated to the kdamond thread.
1032 *
1033 * This structure represents a sysfs command request that need to access some
1034 * DAMON context-internal data. Because DAMON context-internal data can be
1035 * safely accessed from DAMON callbacks without additional synchronization, the
1036 * request will be handled by the DAMON callback. None-``NULL`` @kdamond means
1037 * the request is valid.
1038 */
1039struct damon_sysfs_cmd_request {
1040 enum damon_sysfs_cmd cmd;
1041 struct damon_sysfs_kdamond *kdamond;
1042};
1043
1044/* Current DAMON callback request. Protected by damon_sysfs_lock. */
1045static struct damon_sysfs_cmd_request damon_sysfs_cmd_request;
1046
1047static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr,
1048 char *buf)
1049{
1050 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1051 struct damon_sysfs_kdamond, kobj);
1052 struct damon_ctx *ctx = kdamond->damon_ctx;
1053 bool running;
1054
1055 if (!ctx)
1056 running = false;
1057 else
1058 running = damon_sysfs_ctx_running(ctx);
1059
1060 return sysfs_emit(buf, "%s\n", running ?
1061 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_ON] :
1062 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_OFF]);
1063}
1064
1065static int damon_sysfs_set_attrs(struct damon_ctx *ctx,
1066 struct damon_sysfs_attrs *sys_attrs)
1067{
1068 struct damon_sysfs_intervals *sys_intervals = sys_attrs->intervals;
1069 struct damon_sysfs_ul_range *sys_nr_regions =
1070 sys_attrs->nr_regions_range;
1071 struct damon_attrs attrs = {
1072 .sample_interval = sys_intervals->sample_us,
1073 .aggr_interval = sys_intervals->aggr_us,
1074 .ops_update_interval = sys_intervals->update_us,
1075 .min_nr_regions = sys_nr_regions->min,
1076 .max_nr_regions = sys_nr_regions->max,
1077 };
1078 return damon_set_attrs(ctx, &attrs);
1079}
1080
1081static void damon_sysfs_destroy_targets(struct damon_ctx *ctx)
1082{
1083 struct damon_target *t, *next;
1084 bool has_pid = damon_target_has_pid(ctx);
1085
1086 damon_for_each_target_safe(t, next, ctx) {
1087 if (has_pid)
1088 put_pid(t->pid);
1089 damon_destroy_target(t);
1090 }
1091}
1092
1093static int damon_sysfs_set_regions(struct damon_target *t,
1094 struct damon_sysfs_regions *sysfs_regions)
1095{
1096 struct damon_addr_range *ranges = kmalloc_array(sysfs_regions->nr,
1097 sizeof(*ranges), GFP_KERNEL | __GFP_NOWARN);
1098 int i, err = -EINVAL;
1099
1100 if (!ranges)
1101 return -ENOMEM;
1102 for (i = 0; i < sysfs_regions->nr; i++) {
1103 struct damon_sysfs_region *sys_region =
1104 sysfs_regions->regions_arr[i];
1105
1106 if (sys_region->ar.start > sys_region->ar.end)
1107 goto out;
1108
1109 ranges[i].start = sys_region->ar.start;
1110 ranges[i].end = sys_region->ar.end;
1111 if (i == 0)
1112 continue;
1113 if (ranges[i - 1].end > ranges[i].start)
1114 goto out;
1115 }
1116 err = damon_set_regions(t, ranges, sysfs_regions->nr);
1117out:
1118 kfree(ranges);
1119 return err;
1120
1121}
1122
1123static int damon_sysfs_add_target(struct damon_sysfs_target *sys_target,
1124 struct damon_ctx *ctx)
1125{
1126 struct damon_target *t = damon_new_target();
1127 int err = -EINVAL;
1128
1129 if (!t)
1130 return -ENOMEM;
1131 damon_add_target(ctx, t);
1132 if (damon_target_has_pid(ctx)) {
1133 t->pid = find_get_pid(sys_target->pid);
1134 if (!t->pid)
1135 goto destroy_targets_out;
1136 }
1137 err = damon_sysfs_set_regions(t, sys_target->regions);
1138 if (err)
1139 goto destroy_targets_out;
1140 return 0;
1141
1142destroy_targets_out:
1143 damon_sysfs_destroy_targets(ctx);
1144 return err;
1145}
1146
1147/*
1148 * Search a target in a context that corresponds to the sysfs target input.
1149 *
1150 * Return: pointer to the target if found, NULL if not found, or negative
1151 * error code if the search failed.
1152 */
1153static struct damon_target *damon_sysfs_existing_target(
1154 struct damon_sysfs_target *sys_target, struct damon_ctx *ctx)
1155{
1156 struct pid *pid;
1157 struct damon_target *t;
1158
1159 if (!damon_target_has_pid(ctx)) {
1160 /* Up to only one target for paddr could exist */
1161 damon_for_each_target(t, ctx)
1162 return t;
1163 return NULL;
1164 }
1165
1166 /* ops.id should be DAMON_OPS_VADDR or DAMON_OPS_FVADDR */
1167 pid = find_get_pid(sys_target->pid);
1168 if (!pid)
1169 return ERR_PTR(-EINVAL);
1170 damon_for_each_target(t, ctx) {
1171 if (t->pid == pid) {
1172 put_pid(pid);
1173 return t;
1174 }
1175 }
1176 put_pid(pid);
1177 return NULL;
1178}
1179
1180static int damon_sysfs_set_targets(struct damon_ctx *ctx,
1181 struct damon_sysfs_targets *sysfs_targets)
1182{
1183 int i, err;
1184
1185 /* Multiple physical address space monitoring targets makes no sense */
1186 if (ctx->ops.id == DAMON_OPS_PADDR && sysfs_targets->nr > 1)
1187 return -EINVAL;
1188
1189 for (i = 0; i < sysfs_targets->nr; i++) {
1190 struct damon_sysfs_target *st = sysfs_targets->targets_arr[i];
1191 struct damon_target *t = damon_sysfs_existing_target(st, ctx);
1192
1193 if (IS_ERR(t))
1194 return PTR_ERR(t);
1195 if (!t)
1196 err = damon_sysfs_add_target(st, ctx);
1197 else
1198 err = damon_sysfs_set_regions(t, st->regions);
1199 if (err)
1200 return err;
1201 }
1202 return 0;
1203}
1204
1205static void damon_sysfs_before_terminate(struct damon_ctx *ctx)
1206{
1207 struct damon_target *t, *next;
1208 struct damon_sysfs_kdamond *kdamond;
1209
1210 /* damon_sysfs_schemes_update_regions_stop() might not yet called */
1211 kdamond = damon_sysfs_cmd_request.kdamond;
1212 if (kdamond && damon_sysfs_cmd_request.cmd ==
1213 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS &&
1214 ctx == kdamond->damon_ctx) {
1215 damon_sysfs_schemes_update_regions_stop(ctx);
1216 mutex_unlock(&damon_sysfs_lock);
1217 }
1218
1219 if (!damon_target_has_pid(ctx))
1220 return;
1221
1222 mutex_lock(&ctx->kdamond_lock);
1223 damon_for_each_target_safe(t, next, ctx) {
1224 put_pid(t->pid);
1225 damon_destroy_target(t);
1226 }
1227 mutex_unlock(&ctx->kdamond_lock);
1228}
1229
1230/*
1231 * damon_sysfs_upd_schemes_stats() - Update schemes stats sysfs files.
1232 * @kdamond: The kobject wrapper that associated to the kdamond thread.
1233 *
1234 * This function reads the schemes stats of specific kdamond and update the
1235 * related values for sysfs files. This function should be called from DAMON
1236 * callbacks while holding ``damon_syfs_lock``, to safely access the DAMON
1237 * contexts-internal data and DAMON sysfs variables.
1238 */
1239static int damon_sysfs_upd_schemes_stats(struct damon_sysfs_kdamond *kdamond)
1240{
1241 struct damon_ctx *ctx = kdamond->damon_ctx;
1242
1243 if (!ctx)
1244 return -EINVAL;
1245 damon_sysfs_schemes_update_stats(
1246 kdamond->contexts->contexts_arr[0]->schemes, ctx);
1247 return 0;
1248}
1249
1250static int damon_sysfs_upd_schemes_regions_start(
1251 struct damon_sysfs_kdamond *kdamond)
1252{
1253 struct damon_ctx *ctx = kdamond->damon_ctx;
1254
1255 if (!ctx)
1256 return -EINVAL;
1257 return damon_sysfs_schemes_update_regions_start(
1258 kdamond->contexts->contexts_arr[0]->schemes, ctx);
1259}
1260
1261static int damon_sysfs_upd_schemes_regions_stop(
1262 struct damon_sysfs_kdamond *kdamond)
1263{
1264 struct damon_ctx *ctx = kdamond->damon_ctx;
1265
1266 if (!ctx)
1267 return -EINVAL;
1268 return damon_sysfs_schemes_update_regions_stop(ctx);
1269}
1270
1271static int damon_sysfs_clear_schemes_regions(
1272 struct damon_sysfs_kdamond *kdamond)
1273{
1274 struct damon_ctx *ctx = kdamond->damon_ctx;
1275
1276 if (!ctx)
1277 return -EINVAL;
1278 return damon_sysfs_schemes_clear_regions(
1279 kdamond->contexts->contexts_arr[0]->schemes, ctx);
1280}
1281
1282static inline bool damon_sysfs_kdamond_running(
1283 struct damon_sysfs_kdamond *kdamond)
1284{
1285 return kdamond->damon_ctx &&
1286 damon_sysfs_ctx_running(kdamond->damon_ctx);
1287}
1288
1289static int damon_sysfs_apply_inputs(struct damon_ctx *ctx,
1290 struct damon_sysfs_context *sys_ctx)
1291{
1292 int err;
1293
1294 err = damon_select_ops(ctx, sys_ctx->ops_id);
1295 if (err)
1296 return err;
1297 err = damon_sysfs_set_attrs(ctx, sys_ctx->attrs);
1298 if (err)
1299 return err;
1300 err = damon_sysfs_set_targets(ctx, sys_ctx->targets);
1301 if (err)
1302 return err;
1303 return damon_sysfs_set_schemes(ctx, sys_ctx->schemes);
1304}
1305
1306/*
1307 * damon_sysfs_commit_input() - Commit user inputs to a running kdamond.
1308 * @kdamond: The kobject wrapper for the associated kdamond.
1309 *
1310 * If the sysfs input is wrong, the kdamond will be terminated.
1311 */
1312static int damon_sysfs_commit_input(struct damon_sysfs_kdamond *kdamond)
1313{
1314 if (!damon_sysfs_kdamond_running(kdamond))
1315 return -EINVAL;
1316 /* TODO: Support multiple contexts per kdamond */
1317 if (kdamond->contexts->nr != 1)
1318 return -EINVAL;
1319
1320 return damon_sysfs_apply_inputs(kdamond->damon_ctx,
1321 kdamond->contexts->contexts_arr[0]);
1322}
1323
1324/*
1325 * damon_sysfs_cmd_request_callback() - DAMON callback for handling requests.
1326 * @c: The DAMON context of the callback.
1327 *
1328 * This function is periodically called back from the kdamond thread for @c.
1329 * Then, it checks if there is a waiting DAMON sysfs request and handles it.
1330 */
1331static int damon_sysfs_cmd_request_callback(struct damon_ctx *c)
1332{
1333 struct damon_sysfs_kdamond *kdamond;
1334 static bool damon_sysfs_schemes_regions_updating;
1335 int err = 0;
1336
1337 /* avoid deadlock due to concurrent state_store('off') */
1338 if (!damon_sysfs_schemes_regions_updating &&
1339 !mutex_trylock(&damon_sysfs_lock))
1340 return 0;
1341 kdamond = damon_sysfs_cmd_request.kdamond;
1342 if (!kdamond || kdamond->damon_ctx != c)
1343 goto out;
1344 switch (damon_sysfs_cmd_request.cmd) {
1345 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS:
1346 err = damon_sysfs_upd_schemes_stats(kdamond);
1347 break;
1348 case DAMON_SYSFS_CMD_COMMIT:
1349 err = damon_sysfs_commit_input(kdamond);
1350 break;
1351 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS:
1352 if (!damon_sysfs_schemes_regions_updating) {
1353 err = damon_sysfs_upd_schemes_regions_start(kdamond);
1354 if (!err) {
1355 damon_sysfs_schemes_regions_updating = true;
1356 goto keep_lock_out;
1357 }
1358 } else {
1359 err = damon_sysfs_upd_schemes_regions_stop(kdamond);
1360 damon_sysfs_schemes_regions_updating = false;
1361 }
1362 break;
1363 case DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS:
1364 err = damon_sysfs_clear_schemes_regions(kdamond);
1365 break;
1366 default:
1367 break;
1368 }
1369 /* Mark the request as invalid now. */
1370 damon_sysfs_cmd_request.kdamond = NULL;
1371out:
1372 if (!damon_sysfs_schemes_regions_updating)
1373 mutex_unlock(&damon_sysfs_lock);
1374keep_lock_out:
1375 return err;
1376}
1377
1378static struct damon_ctx *damon_sysfs_build_ctx(
1379 struct damon_sysfs_context *sys_ctx)
1380{
1381 struct damon_ctx *ctx = damon_new_ctx();
1382 int err;
1383
1384 if (!ctx)
1385 return ERR_PTR(-ENOMEM);
1386
1387 err = damon_sysfs_apply_inputs(ctx, sys_ctx);
1388 if (err) {
1389 damon_destroy_ctx(ctx);
1390 return ERR_PTR(err);
1391 }
1392
1393 ctx->callback.after_wmarks_check = damon_sysfs_cmd_request_callback;
1394 ctx->callback.after_aggregation = damon_sysfs_cmd_request_callback;
1395 ctx->callback.before_terminate = damon_sysfs_before_terminate;
1396 return ctx;
1397}
1398
1399static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond)
1400{
1401 struct damon_ctx *ctx;
1402 int err;
1403
1404 if (damon_sysfs_kdamond_running(kdamond))
1405 return -EBUSY;
1406 if (damon_sysfs_cmd_request.kdamond == kdamond)
1407 return -EBUSY;
1408 /* TODO: support multiple contexts per kdamond */
1409 if (kdamond->contexts->nr != 1)
1410 return -EINVAL;
1411
1412 if (kdamond->damon_ctx)
1413 damon_destroy_ctx(kdamond->damon_ctx);
1414 kdamond->damon_ctx = NULL;
1415
1416 ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]);
1417 if (IS_ERR(ctx))
1418 return PTR_ERR(ctx);
1419 err = damon_start(&ctx, 1, false);
1420 if (err) {
1421 damon_destroy_ctx(ctx);
1422 return err;
1423 }
1424 kdamond->damon_ctx = ctx;
1425 return err;
1426}
1427
1428static int damon_sysfs_turn_damon_off(struct damon_sysfs_kdamond *kdamond)
1429{
1430 if (!kdamond->damon_ctx)
1431 return -EINVAL;
1432 return damon_stop(&kdamond->damon_ctx, 1);
1433 /*
1434 * To allow users show final monitoring results of already turned-off
1435 * DAMON, we free kdamond->damon_ctx in next
1436 * damon_sysfs_turn_damon_on(), or kdamonds_nr_store()
1437 */
1438}
1439
1440/*
1441 * damon_sysfs_handle_cmd() - Handle a command for a specific kdamond.
1442 * @cmd: The command to handle.
1443 * @kdamond: The kobject wrapper for the associated kdamond.
1444 *
1445 * This function handles a DAMON sysfs command for a kdamond. For commands
1446 * that need to access running DAMON context-internal data, it requests
1447 * handling of the command to the DAMON callback
1448 * (@damon_sysfs_cmd_request_callback()) and wait until it is properly handled,
1449 * or the context is completed.
1450 *
1451 * Return: 0 on success, negative error code otherwise.
1452 */
1453static int damon_sysfs_handle_cmd(enum damon_sysfs_cmd cmd,
1454 struct damon_sysfs_kdamond *kdamond)
1455{
1456 bool need_wait = true;
1457
1458 /* Handle commands that doesn't access DAMON context-internal data */
1459 switch (cmd) {
1460 case DAMON_SYSFS_CMD_ON:
1461 return damon_sysfs_turn_damon_on(kdamond);
1462 case DAMON_SYSFS_CMD_OFF:
1463 return damon_sysfs_turn_damon_off(kdamond);
1464 default:
1465 break;
1466 }
1467
1468 /* Pass the command to DAMON callback for safe DAMON context access */
1469 if (damon_sysfs_cmd_request.kdamond)
1470 return -EBUSY;
1471 if (!damon_sysfs_kdamond_running(kdamond))
1472 return -EINVAL;
1473 damon_sysfs_cmd_request.cmd = cmd;
1474 damon_sysfs_cmd_request.kdamond = kdamond;
1475
1476 /*
1477 * wait until damon_sysfs_cmd_request_callback() handles the request
1478 * from kdamond context
1479 */
1480 mutex_unlock(&damon_sysfs_lock);
1481 while (need_wait) {
1482 schedule_timeout_idle(msecs_to_jiffies(100));
1483 if (!mutex_trylock(&damon_sysfs_lock))
1484 continue;
1485 if (!damon_sysfs_cmd_request.kdamond) {
1486 /* damon_sysfs_cmd_request_callback() handled */
1487 need_wait = false;
1488 } else if (!damon_sysfs_kdamond_running(kdamond)) {
1489 /* kdamond has already finished */
1490 need_wait = false;
1491 damon_sysfs_cmd_request.kdamond = NULL;
1492 }
1493 mutex_unlock(&damon_sysfs_lock);
1494 }
1495 mutex_lock(&damon_sysfs_lock);
1496 return 0;
1497}
1498
1499static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,
1500 const char *buf, size_t count)
1501{
1502 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1503 struct damon_sysfs_kdamond, kobj);
1504 enum damon_sysfs_cmd cmd;
1505 ssize_t ret = -EINVAL;
1506
1507 if (!mutex_trylock(&damon_sysfs_lock))
1508 return -EBUSY;
1509 for (cmd = 0; cmd < NR_DAMON_SYSFS_CMDS; cmd++) {
1510 if (sysfs_streq(buf, damon_sysfs_cmd_strs[cmd])) {
1511 ret = damon_sysfs_handle_cmd(cmd, kdamond);
1512 break;
1513 }
1514 }
1515 mutex_unlock(&damon_sysfs_lock);
1516 if (!ret)
1517 ret = count;
1518 return ret;
1519}
1520
1521static ssize_t pid_show(struct kobject *kobj,
1522 struct kobj_attribute *attr, char *buf)
1523{
1524 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1525 struct damon_sysfs_kdamond, kobj);
1526 struct damon_ctx *ctx;
1527 int pid = -1;
1528
1529 if (!mutex_trylock(&damon_sysfs_lock))
1530 return -EBUSY;
1531 ctx = kdamond->damon_ctx;
1532 if (!ctx)
1533 goto out;
1534
1535 mutex_lock(&ctx->kdamond_lock);
1536 if (ctx->kdamond)
1537 pid = ctx->kdamond->pid;
1538 mutex_unlock(&ctx->kdamond_lock);
1539out:
1540 mutex_unlock(&damon_sysfs_lock);
1541 return sysfs_emit(buf, "%d\n", pid);
1542}
1543
1544static void damon_sysfs_kdamond_release(struct kobject *kobj)
1545{
1546 struct damon_sysfs_kdamond *kdamond = container_of(kobj,
1547 struct damon_sysfs_kdamond, kobj);
1548
1549 if (kdamond->damon_ctx)
1550 damon_destroy_ctx(kdamond->damon_ctx);
1551 kfree(kdamond);
1552}
1553
1554static struct kobj_attribute damon_sysfs_kdamond_state_attr =
1555 __ATTR_RW_MODE(state, 0600);
1556
1557static struct kobj_attribute damon_sysfs_kdamond_pid_attr =
1558 __ATTR_RO_MODE(pid, 0400);
1559
1560static struct attribute *damon_sysfs_kdamond_attrs[] = {
1561 &damon_sysfs_kdamond_state_attr.attr,
1562 &damon_sysfs_kdamond_pid_attr.attr,
1563 NULL,
1564};
1565ATTRIBUTE_GROUPS(damon_sysfs_kdamond);
1566
1567static struct kobj_type damon_sysfs_kdamond_ktype = {
1568 .release = damon_sysfs_kdamond_release,
1569 .sysfs_ops = &kobj_sysfs_ops,
1570 .default_groups = damon_sysfs_kdamond_groups,
1571};
1572
1573/*
1574 * kdamonds directory
1575 */
1576
1577struct damon_sysfs_kdamonds {
1578 struct kobject kobj;
1579 struct damon_sysfs_kdamond **kdamonds_arr;
1580 int nr;
1581};
1582
1583static struct damon_sysfs_kdamonds *damon_sysfs_kdamonds_alloc(void)
1584{
1585 return kzalloc(sizeof(struct damon_sysfs_kdamonds), GFP_KERNEL);
1586}
1587
1588static void damon_sysfs_kdamonds_rm_dirs(struct damon_sysfs_kdamonds *kdamonds)
1589{
1590 struct damon_sysfs_kdamond **kdamonds_arr = kdamonds->kdamonds_arr;
1591 int i;
1592
1593 for (i = 0; i < kdamonds->nr; i++) {
1594 damon_sysfs_kdamond_rm_dirs(kdamonds_arr[i]);
1595 kobject_put(&kdamonds_arr[i]->kobj);
1596 }
1597 kdamonds->nr = 0;
1598 kfree(kdamonds_arr);
1599 kdamonds->kdamonds_arr = NULL;
1600}
1601
1602static bool damon_sysfs_kdamonds_busy(struct damon_sysfs_kdamond **kdamonds,
1603 int nr_kdamonds)
1604{
1605 int i;
1606
1607 for (i = 0; i < nr_kdamonds; i++) {
1608 if (damon_sysfs_kdamond_running(kdamonds[i]) ||
1609 damon_sysfs_cmd_request.kdamond == kdamonds[i])
1610 return true;
1611 }
1612
1613 return false;
1614}
1615
1616static int damon_sysfs_kdamonds_add_dirs(struct damon_sysfs_kdamonds *kdamonds,
1617 int nr_kdamonds)
1618{
1619 struct damon_sysfs_kdamond **kdamonds_arr, *kdamond;
1620 int err, i;
1621
1622 if (damon_sysfs_kdamonds_busy(kdamonds->kdamonds_arr, kdamonds->nr))
1623 return -EBUSY;
1624
1625 damon_sysfs_kdamonds_rm_dirs(kdamonds);
1626 if (!nr_kdamonds)
1627 return 0;
1628
1629 kdamonds_arr = kmalloc_array(nr_kdamonds, sizeof(*kdamonds_arr),
1630 GFP_KERNEL | __GFP_NOWARN);
1631 if (!kdamonds_arr)
1632 return -ENOMEM;
1633 kdamonds->kdamonds_arr = kdamonds_arr;
1634
1635 for (i = 0; i < nr_kdamonds; i++) {
1636 kdamond = damon_sysfs_kdamond_alloc();
1637 if (!kdamond) {
1638 damon_sysfs_kdamonds_rm_dirs(kdamonds);
1639 return -ENOMEM;
1640 }
1641
1642 err = kobject_init_and_add(&kdamond->kobj,
1643 &damon_sysfs_kdamond_ktype, &kdamonds->kobj,
1644 "%d", i);
1645 if (err)
1646 goto out;
1647
1648 err = damon_sysfs_kdamond_add_dirs(kdamond);
1649 if (err)
1650 goto out;
1651
1652 kdamonds_arr[i] = kdamond;
1653 kdamonds->nr++;
1654 }
1655 return 0;
1656
1657out:
1658 damon_sysfs_kdamonds_rm_dirs(kdamonds);
1659 kobject_put(&kdamond->kobj);
1660 return err;
1661}
1662
1663static ssize_t nr_kdamonds_show(struct kobject *kobj,
1664 struct kobj_attribute *attr, char *buf)
1665{
1666 struct damon_sysfs_kdamonds *kdamonds = container_of(kobj,
1667 struct damon_sysfs_kdamonds, kobj);
1668
1669 return sysfs_emit(buf, "%d\n", kdamonds->nr);
1670}
1671
1672static ssize_t nr_kdamonds_store(struct kobject *kobj,
1673 struct kobj_attribute *attr, const char *buf, size_t count)
1674{
1675 struct damon_sysfs_kdamonds *kdamonds;
1676 int nr, err;
1677
1678 err = kstrtoint(buf, 0, &nr);
1679 if (err)
1680 return err;
1681 if (nr < 0)
1682 return -EINVAL;
1683
1684 kdamonds = container_of(kobj, struct damon_sysfs_kdamonds, kobj);
1685
1686 if (!mutex_trylock(&damon_sysfs_lock))
1687 return -EBUSY;
1688 err = damon_sysfs_kdamonds_add_dirs(kdamonds, nr);
1689 mutex_unlock(&damon_sysfs_lock);
1690 if (err)
1691 return err;
1692
1693 return count;
1694}
1695
1696static void damon_sysfs_kdamonds_release(struct kobject *kobj)
1697{
1698 kfree(container_of(kobj, struct damon_sysfs_kdamonds, kobj));
1699}
1700
1701static struct kobj_attribute damon_sysfs_kdamonds_nr_attr =
1702 __ATTR_RW_MODE(nr_kdamonds, 0600);
1703
1704static struct attribute *damon_sysfs_kdamonds_attrs[] = {
1705 &damon_sysfs_kdamonds_nr_attr.attr,
1706 NULL,
1707};
1708ATTRIBUTE_GROUPS(damon_sysfs_kdamonds);
1709
1710static struct kobj_type damon_sysfs_kdamonds_ktype = {
1711 .release = damon_sysfs_kdamonds_release,
1712 .sysfs_ops = &kobj_sysfs_ops,
1713 .default_groups = damon_sysfs_kdamonds_groups,
1714};
1715
1716/*
1717 * damon user interface directory
1718 */
1719
1720struct damon_sysfs_ui_dir {
1721 struct kobject kobj;
1722 struct damon_sysfs_kdamonds *kdamonds;
1723};
1724
1725static struct damon_sysfs_ui_dir *damon_sysfs_ui_dir_alloc(void)
1726{
1727 return kzalloc(sizeof(struct damon_sysfs_ui_dir), GFP_KERNEL);
1728}
1729
1730static int damon_sysfs_ui_dir_add_dirs(struct damon_sysfs_ui_dir *ui_dir)
1731{
1732 struct damon_sysfs_kdamonds *kdamonds;
1733 int err;
1734
1735 kdamonds = damon_sysfs_kdamonds_alloc();
1736 if (!kdamonds)
1737 return -ENOMEM;
1738
1739 err = kobject_init_and_add(&kdamonds->kobj,
1740 &damon_sysfs_kdamonds_ktype, &ui_dir->kobj,
1741 "kdamonds");
1742 if (err) {
1743 kobject_put(&kdamonds->kobj);
1744 return err;
1745 }
1746 ui_dir->kdamonds = kdamonds;
1747 return err;
1748}
1749
1750static void damon_sysfs_ui_dir_release(struct kobject *kobj)
1751{
1752 kfree(container_of(kobj, struct damon_sysfs_ui_dir, kobj));
1753}
1754
1755static struct attribute *damon_sysfs_ui_dir_attrs[] = {
1756 NULL,
1757};
1758ATTRIBUTE_GROUPS(damon_sysfs_ui_dir);
1759
1760static struct kobj_type damon_sysfs_ui_dir_ktype = {
1761 .release = damon_sysfs_ui_dir_release,
1762 .sysfs_ops = &kobj_sysfs_ops,
1763 .default_groups = damon_sysfs_ui_dir_groups,
1764};
1765
1766static int __init damon_sysfs_init(void)
1767{
1768 struct kobject *damon_sysfs_root;
1769 struct damon_sysfs_ui_dir *admin;
1770 int err;
1771
1772 damon_sysfs_root = kobject_create_and_add("damon", mm_kobj);
1773 if (!damon_sysfs_root)
1774 return -ENOMEM;
1775
1776 admin = damon_sysfs_ui_dir_alloc();
1777 if (!admin) {
1778 kobject_put(damon_sysfs_root);
1779 return -ENOMEM;
1780 }
1781 err = kobject_init_and_add(&admin->kobj, &damon_sysfs_ui_dir_ktype,
1782 damon_sysfs_root, "admin");
1783 if (err)
1784 goto out;
1785 err = damon_sysfs_ui_dir_add_dirs(admin);
1786 if (err)
1787 goto out;
1788 return 0;
1789
1790out:
1791 kobject_put(&admin->kobj);
1792 kobject_put(damon_sysfs_root);
1793 return err;
1794}
1795subsys_initcall(damon_sysfs_init);