1886 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * DAMON sysfs Interface4 *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 directory16 */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 directory92 */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 directory209 */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 else235 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 directory288 */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 directory413 */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 directory541 */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 directory623 */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 directory811 */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_attr921 = __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 directory937 */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 goals999 * to DAMON.1000 */1001 DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS,1002 /*1003 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS: Update scheme stats sysfs1004 * files.1005 */1006 DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS,1007 /*1008 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES: Update1009 * 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 tried1014 * regions1015 */1016 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS,1017 /*1018 * @DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS: Clear schemes tried1019 * regions1020 */1021 DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS,1022 /*1023 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS: Update the1024 * 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 some1052 * DAMON context-internal data. Because DAMON context-internal data can be1053 * safely accessed from DAMON callbacks without additional synchronization, the1054 * request will be handled by the DAMON callback. None-``NULL`` @kdamond means1055 * 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 else1076 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_add_targets(struct damon_ctx *ctx,1166 struct damon_sysfs_targets *sysfs_targets)1167{1168 int i, err;1169 1170 /* Multiple physical address space monitoring targets makes no sense */1171 if (ctx->ops.id == DAMON_OPS_PADDR && sysfs_targets->nr > 1)1172 return -EINVAL;1173 1174 for (i = 0; i < sysfs_targets->nr; i++) {1175 struct damon_sysfs_target *st = sysfs_targets->targets_arr[i];1176 1177 err = damon_sysfs_add_target(st, ctx);1178 if (err)1179 return err;1180 }1181 return 0;1182}1183 1184static bool damon_sysfs_schemes_regions_updating;1185 1186static void damon_sysfs_before_terminate(struct damon_ctx *ctx)1187{1188 struct damon_target *t, *next;1189 struct damon_sysfs_kdamond *kdamond;1190 enum damon_sysfs_cmd cmd;1191 1192 /* damon_sysfs_schemes_update_regions_stop() might not yet called */1193 kdamond = damon_sysfs_cmd_request.kdamond;1194 cmd = damon_sysfs_cmd_request.cmd;1195 if (kdamond && ctx == kdamond->damon_ctx &&1196 (cmd == DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS ||1197 cmd == DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES) &&1198 damon_sysfs_schemes_regions_updating) {1199 damon_sysfs_schemes_update_regions_stop(ctx);1200 damon_sysfs_schemes_regions_updating = false;1201 mutex_unlock(&damon_sysfs_lock);1202 }1203 1204 if (!damon_target_has_pid(ctx))1205 return;1206 1207 mutex_lock(&ctx->kdamond_lock);1208 damon_for_each_target_safe(t, next, ctx) {1209 put_pid(t->pid);1210 damon_destroy_target(t);1211 }1212 mutex_unlock(&ctx->kdamond_lock);1213}1214 1215/*1216 * damon_sysfs_upd_schemes_stats() - Update schemes stats sysfs files.1217 * @kdamond: The kobject wrapper that associated to the kdamond thread.1218 *1219 * This function reads the schemes stats of specific kdamond and update the1220 * related values for sysfs files. This function should be called from DAMON1221 * callbacks while holding ``damon_syfs_lock``, to safely access the DAMON1222 * contexts-internal data and DAMON sysfs variables.1223 */1224static int damon_sysfs_upd_schemes_stats(struct damon_sysfs_kdamond *kdamond)1225{1226 struct damon_ctx *ctx = kdamond->damon_ctx;1227 1228 if (!ctx)1229 return -EINVAL;1230 damon_sysfs_schemes_update_stats(1231 kdamond->contexts->contexts_arr[0]->schemes, ctx);1232 return 0;1233}1234 1235static int damon_sysfs_upd_schemes_regions_start(1236 struct damon_sysfs_kdamond *kdamond, bool total_bytes_only)1237{1238 struct damon_ctx *ctx = kdamond->damon_ctx;1239 1240 if (!ctx)1241 return -EINVAL;1242 return damon_sysfs_schemes_update_regions_start(1243 kdamond->contexts->contexts_arr[0]->schemes, ctx,1244 total_bytes_only);1245}1246 1247static int damon_sysfs_upd_schemes_regions_stop(1248 struct damon_sysfs_kdamond *kdamond)1249{1250 struct damon_ctx *ctx = kdamond->damon_ctx;1251 1252 if (!ctx)1253 return -EINVAL;1254 return damon_sysfs_schemes_update_regions_stop(ctx);1255}1256 1257static int damon_sysfs_clear_schemes_regions(1258 struct damon_sysfs_kdamond *kdamond)1259{1260 struct damon_ctx *ctx = kdamond->damon_ctx;1261 1262 if (!ctx)1263 return -EINVAL;1264 return damon_sysfs_schemes_clear_regions(1265 kdamond->contexts->contexts_arr[0]->schemes, ctx);1266}1267 1268static inline bool damon_sysfs_kdamond_running(1269 struct damon_sysfs_kdamond *kdamond)1270{1271 return kdamond->damon_ctx &&1272 damon_sysfs_ctx_running(kdamond->damon_ctx);1273}1274 1275static int damon_sysfs_apply_inputs(struct damon_ctx *ctx,1276 struct damon_sysfs_context *sys_ctx)1277{1278 int err;1279 1280 err = damon_select_ops(ctx, sys_ctx->ops_id);1281 if (err)1282 return err;1283 err = damon_sysfs_set_attrs(ctx, sys_ctx->attrs);1284 if (err)1285 return err;1286 err = damon_sysfs_add_targets(ctx, sys_ctx->targets);1287 if (err)1288 return err;1289 return damon_sysfs_add_schemes(ctx, sys_ctx->schemes);1290}1291 1292static struct damon_ctx *damon_sysfs_build_ctx(1293 struct damon_sysfs_context *sys_ctx);1294 1295/*1296 * damon_sysfs_commit_input() - Commit user inputs to a running kdamond.1297 * @kdamond: The kobject wrapper for the associated kdamond.1298 *1299 * If the sysfs input is wrong, the kdamond will be terminated.1300 */1301static int damon_sysfs_commit_input(struct damon_sysfs_kdamond *kdamond)1302{1303 struct damon_ctx *param_ctx;1304 int err;1305 1306 if (!damon_sysfs_kdamond_running(kdamond))1307 return -EINVAL;1308 /* TODO: Support multiple contexts per kdamond */1309 if (kdamond->contexts->nr != 1)1310 return -EINVAL;1311 1312 param_ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]);1313 if (IS_ERR(param_ctx))1314 return PTR_ERR(param_ctx);1315 err = damon_commit_ctx(kdamond->damon_ctx, param_ctx);1316 damon_sysfs_destroy_targets(param_ctx);1317 damon_destroy_ctx(param_ctx);1318 return err;1319}1320 1321static int damon_sysfs_commit_schemes_quota_goals(1322 struct damon_sysfs_kdamond *sysfs_kdamond)1323{1324 struct damon_ctx *ctx;1325 struct damon_sysfs_context *sysfs_ctx;1326 1327 if (!damon_sysfs_kdamond_running(sysfs_kdamond))1328 return -EINVAL;1329 /* TODO: Support multiple contexts per kdamond */1330 if (sysfs_kdamond->contexts->nr != 1)1331 return -EINVAL;1332 1333 ctx = sysfs_kdamond->damon_ctx;1334 sysfs_ctx = sysfs_kdamond->contexts->contexts_arr[0];1335 return damos_sysfs_set_quota_scores(sysfs_ctx->schemes, ctx);1336}1337 1338/*1339 * damon_sysfs_upd_schemes_effective_quotas() - Update schemes effective quotas1340 * sysfs files.1341 * @kdamond: The kobject wrapper that associated to the kdamond thread.1342 *1343 * This function reads the schemes' effective quotas of specific kdamond and1344 * update the related values for sysfs files. This function should be called1345 * from DAMON callbacks while holding ``damon_syfs_lock``, to safely access the1346 * DAMON contexts-internal data and DAMON sysfs variables.1347 */1348static int damon_sysfs_upd_schemes_effective_quotas(1349 struct damon_sysfs_kdamond *kdamond)1350{1351 struct damon_ctx *ctx = kdamond->damon_ctx;1352 1353 if (!ctx)1354 return -EINVAL;1355 damos_sysfs_update_effective_quotas(1356 kdamond->contexts->contexts_arr[0]->schemes, ctx);1357 return 0;1358}1359 1360 1361/*1362 * damon_sysfs_cmd_request_callback() - DAMON callback for handling requests.1363 * @c: The DAMON context of the callback.1364 * @active: Whether @c is not deactivated due to watermarks.1365 * @after_aggr: Whether this is called from after_aggregation() callback.1366 *1367 * This function is periodically called back from the kdamond thread for @c.1368 * Then, it checks if there is a waiting DAMON sysfs request and handles it.1369 */1370static int damon_sysfs_cmd_request_callback(struct damon_ctx *c, bool active,1371 bool after_aggregation)1372{1373 struct damon_sysfs_kdamond *kdamond;1374 bool total_bytes_only = false;1375 int err = 0;1376 1377 /* avoid deadlock due to concurrent state_store('off') */1378 if (!damon_sysfs_schemes_regions_updating &&1379 !mutex_trylock(&damon_sysfs_lock))1380 return 0;1381 kdamond = damon_sysfs_cmd_request.kdamond;1382 if (!kdamond || kdamond->damon_ctx != c)1383 goto out;1384 switch (damon_sysfs_cmd_request.cmd) {1385 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS:1386 err = damon_sysfs_upd_schemes_stats(kdamond);1387 break;1388 case DAMON_SYSFS_CMD_COMMIT:1389 if (!after_aggregation)1390 goto out;1391 err = damon_sysfs_commit_input(kdamond);1392 break;1393 case DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS:1394 err = damon_sysfs_commit_schemes_quota_goals(kdamond);1395 break;1396 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES:1397 total_bytes_only = true;1398 fallthrough;1399 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS:1400 if (!damon_sysfs_schemes_regions_updating) {1401 err = damon_sysfs_upd_schemes_regions_start(kdamond,1402 total_bytes_only);1403 if (!err) {1404 damon_sysfs_schemes_regions_updating = true;1405 goto keep_lock_out;1406 }1407 } else {1408 damos_sysfs_mark_finished_regions_updates(c);1409 /*1410 * Continue regions updating if DAMON is till1411 * active and the update for all schemes is not1412 * finished.1413 */1414 if (active && !damos_sysfs_regions_upd_done())1415 goto keep_lock_out;1416 err = damon_sysfs_upd_schemes_regions_stop(kdamond);1417 damon_sysfs_schemes_regions_updating = false;1418 }1419 break;1420 case DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS:1421 err = damon_sysfs_clear_schemes_regions(kdamond);1422 break;1423 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS:1424 err = damon_sysfs_upd_schemes_effective_quotas(kdamond);1425 break;1426 default:1427 break;1428 }1429 /* Mark the request as invalid now. */1430 damon_sysfs_cmd_request.kdamond = NULL;1431out:1432 if (!damon_sysfs_schemes_regions_updating)1433 mutex_unlock(&damon_sysfs_lock);1434keep_lock_out:1435 return err;1436}1437 1438static int damon_sysfs_after_wmarks_check(struct damon_ctx *c)1439{1440 /*1441 * after_wmarks_check() is called back while the context is deactivated1442 * by watermarks.1443 */1444 return damon_sysfs_cmd_request_callback(c, false, false);1445}1446 1447static int damon_sysfs_after_sampling(struct damon_ctx *c)1448{1449 /*1450 * after_sampling() is called back only while the context is not1451 * deactivated by watermarks.1452 */1453 return damon_sysfs_cmd_request_callback(c, true, false);1454}1455 1456static int damon_sysfs_after_aggregation(struct damon_ctx *c)1457{1458 /*1459 * after_aggregation() is called back only while the context is not1460 * deactivated by watermarks.1461 */1462 return damon_sysfs_cmd_request_callback(c, true, true);1463}1464 1465static struct damon_ctx *damon_sysfs_build_ctx(1466 struct damon_sysfs_context *sys_ctx)1467{1468 struct damon_ctx *ctx = damon_new_ctx();1469 int err;1470 1471 if (!ctx)1472 return ERR_PTR(-ENOMEM);1473 1474 err = damon_sysfs_apply_inputs(ctx, sys_ctx);1475 if (err) {1476 damon_destroy_ctx(ctx);1477 return ERR_PTR(err);1478 }1479 1480 ctx->callback.after_wmarks_check = damon_sysfs_after_wmarks_check;1481 ctx->callback.after_sampling = damon_sysfs_after_sampling;1482 ctx->callback.after_aggregation = damon_sysfs_after_aggregation;1483 ctx->callback.before_terminate = damon_sysfs_before_terminate;1484 return ctx;1485}1486 1487static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond)1488{1489 struct damon_ctx *ctx;1490 int err;1491 1492 if (damon_sysfs_kdamond_running(kdamond))1493 return -EBUSY;1494 if (damon_sysfs_cmd_request.kdamond == kdamond)1495 return -EBUSY;1496 /* TODO: support multiple contexts per kdamond */1497 if (kdamond->contexts->nr != 1)1498 return -EINVAL;1499 1500 if (kdamond->damon_ctx)1501 damon_destroy_ctx(kdamond->damon_ctx);1502 kdamond->damon_ctx = NULL;1503 1504 ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]);1505 if (IS_ERR(ctx))1506 return PTR_ERR(ctx);1507 err = damon_start(&ctx, 1, false);1508 if (err) {1509 damon_destroy_ctx(ctx);1510 return err;1511 }1512 kdamond->damon_ctx = ctx;1513 return err;1514}1515 1516static int damon_sysfs_turn_damon_off(struct damon_sysfs_kdamond *kdamond)1517{1518 if (!kdamond->damon_ctx)1519 return -EINVAL;1520 return damon_stop(&kdamond->damon_ctx, 1);1521 /*1522 * To allow users show final monitoring results of already turned-off1523 * DAMON, we free kdamond->damon_ctx in next1524 * damon_sysfs_turn_damon_on(), or kdamonds_nr_store()1525 */1526}1527 1528/*1529 * damon_sysfs_handle_cmd() - Handle a command for a specific kdamond.1530 * @cmd: The command to handle.1531 * @kdamond: The kobject wrapper for the associated kdamond.1532 *1533 * This function handles a DAMON sysfs command for a kdamond. For commands1534 * that need to access running DAMON context-internal data, it requests1535 * handling of the command to the DAMON callback1536 * (@damon_sysfs_cmd_request_callback()) and wait until it is properly handled,1537 * or the context is completed.1538 *1539 * Return: 0 on success, negative error code otherwise.1540 */1541static int damon_sysfs_handle_cmd(enum damon_sysfs_cmd cmd,1542 struct damon_sysfs_kdamond *kdamond)1543{1544 bool need_wait = true;1545 1546 /* Handle commands that doesn't access DAMON context-internal data */1547 switch (cmd) {1548 case DAMON_SYSFS_CMD_ON:1549 return damon_sysfs_turn_damon_on(kdamond);1550 case DAMON_SYSFS_CMD_OFF:1551 return damon_sysfs_turn_damon_off(kdamond);1552 default:1553 break;1554 }1555 1556 /* Pass the command to DAMON callback for safe DAMON context access */1557 if (damon_sysfs_cmd_request.kdamond)1558 return -EBUSY;1559 if (!damon_sysfs_kdamond_running(kdamond))1560 return -EINVAL;1561 damon_sysfs_cmd_request.cmd = cmd;1562 damon_sysfs_cmd_request.kdamond = kdamond;1563 1564 /*1565 * wait until damon_sysfs_cmd_request_callback() handles the request1566 * from kdamond context1567 */1568 mutex_unlock(&damon_sysfs_lock);1569 while (need_wait) {1570 schedule_timeout_idle(msecs_to_jiffies(100));1571 if (!mutex_trylock(&damon_sysfs_lock))1572 continue;1573 if (!damon_sysfs_cmd_request.kdamond) {1574 /* damon_sysfs_cmd_request_callback() handled */1575 need_wait = false;1576 } else if (!damon_sysfs_kdamond_running(kdamond)) {1577 /* kdamond has already finished */1578 need_wait = false;1579 damon_sysfs_cmd_request.kdamond = NULL;1580 }1581 mutex_unlock(&damon_sysfs_lock);1582 }1583 mutex_lock(&damon_sysfs_lock);1584 return 0;1585}1586 1587static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr,1588 const char *buf, size_t count)1589{1590 struct damon_sysfs_kdamond *kdamond = container_of(kobj,1591 struct damon_sysfs_kdamond, kobj);1592 enum damon_sysfs_cmd cmd;1593 ssize_t ret = -EINVAL;1594 1595 if (!mutex_trylock(&damon_sysfs_lock))1596 return -EBUSY;1597 for (cmd = 0; cmd < NR_DAMON_SYSFS_CMDS; cmd++) {1598 if (sysfs_streq(buf, damon_sysfs_cmd_strs[cmd])) {1599 ret = damon_sysfs_handle_cmd(cmd, kdamond);1600 break;1601 }1602 }1603 mutex_unlock(&damon_sysfs_lock);1604 if (!ret)1605 ret = count;1606 return ret;1607}1608 1609static ssize_t pid_show(struct kobject *kobj,1610 struct kobj_attribute *attr, char *buf)1611{1612 struct damon_sysfs_kdamond *kdamond = container_of(kobj,1613 struct damon_sysfs_kdamond, kobj);1614 struct damon_ctx *ctx;1615 int pid = -1;1616 1617 if (!mutex_trylock(&damon_sysfs_lock))1618 return -EBUSY;1619 ctx = kdamond->damon_ctx;1620 if (!ctx)1621 goto out;1622 1623 mutex_lock(&ctx->kdamond_lock);1624 if (ctx->kdamond)1625 pid = ctx->kdamond->pid;1626 mutex_unlock(&ctx->kdamond_lock);1627out:1628 mutex_unlock(&damon_sysfs_lock);1629 return sysfs_emit(buf, "%d\n", pid);1630}1631 1632static void damon_sysfs_kdamond_release(struct kobject *kobj)1633{1634 struct damon_sysfs_kdamond *kdamond = container_of(kobj,1635 struct damon_sysfs_kdamond, kobj);1636 1637 if (kdamond->damon_ctx)1638 damon_destroy_ctx(kdamond->damon_ctx);1639 kfree(kdamond);1640}1641 1642static struct kobj_attribute damon_sysfs_kdamond_state_attr =1643 __ATTR_RW_MODE(state, 0600);1644 1645static struct kobj_attribute damon_sysfs_kdamond_pid_attr =1646 __ATTR_RO_MODE(pid, 0400);1647 1648static struct attribute *damon_sysfs_kdamond_attrs[] = {1649 &damon_sysfs_kdamond_state_attr.attr,1650 &damon_sysfs_kdamond_pid_attr.attr,1651 NULL,1652};1653ATTRIBUTE_GROUPS(damon_sysfs_kdamond);1654 1655static const struct kobj_type damon_sysfs_kdamond_ktype = {1656 .release = damon_sysfs_kdamond_release,1657 .sysfs_ops = &kobj_sysfs_ops,1658 .default_groups = damon_sysfs_kdamond_groups,1659};1660 1661/*1662 * kdamonds directory1663 */1664 1665struct damon_sysfs_kdamonds {1666 struct kobject kobj;1667 struct damon_sysfs_kdamond **kdamonds_arr;1668 int nr;1669};1670 1671static struct damon_sysfs_kdamonds *damon_sysfs_kdamonds_alloc(void)1672{1673 return kzalloc(sizeof(struct damon_sysfs_kdamonds), GFP_KERNEL);1674}1675 1676static void damon_sysfs_kdamonds_rm_dirs(struct damon_sysfs_kdamonds *kdamonds)1677{1678 struct damon_sysfs_kdamond **kdamonds_arr = kdamonds->kdamonds_arr;1679 int i;1680 1681 for (i = 0; i < kdamonds->nr; i++) {1682 damon_sysfs_kdamond_rm_dirs(kdamonds_arr[i]);1683 kobject_put(&kdamonds_arr[i]->kobj);1684 }1685 kdamonds->nr = 0;1686 kfree(kdamonds_arr);1687 kdamonds->kdamonds_arr = NULL;1688}1689 1690static bool damon_sysfs_kdamonds_busy(struct damon_sysfs_kdamond **kdamonds,1691 int nr_kdamonds)1692{1693 int i;1694 1695 for (i = 0; i < nr_kdamonds; i++) {1696 if (damon_sysfs_kdamond_running(kdamonds[i]) ||1697 damon_sysfs_cmd_request.kdamond == kdamonds[i])1698 return true;1699 }1700 1701 return false;1702}1703 1704static int damon_sysfs_kdamonds_add_dirs(struct damon_sysfs_kdamonds *kdamonds,1705 int nr_kdamonds)1706{1707 struct damon_sysfs_kdamond **kdamonds_arr, *kdamond;1708 int err, i;1709 1710 if (damon_sysfs_kdamonds_busy(kdamonds->kdamonds_arr, kdamonds->nr))1711 return -EBUSY;1712 1713 damon_sysfs_kdamonds_rm_dirs(kdamonds);1714 if (!nr_kdamonds)1715 return 0;1716 1717 kdamonds_arr = kmalloc_array(nr_kdamonds, sizeof(*kdamonds_arr),1718 GFP_KERNEL | __GFP_NOWARN);1719 if (!kdamonds_arr)1720 return -ENOMEM;1721 kdamonds->kdamonds_arr = kdamonds_arr;1722 1723 for (i = 0; i < nr_kdamonds; i++) {1724 kdamond = damon_sysfs_kdamond_alloc();1725 if (!kdamond) {1726 damon_sysfs_kdamonds_rm_dirs(kdamonds);1727 return -ENOMEM;1728 }1729 1730 err = kobject_init_and_add(&kdamond->kobj,1731 &damon_sysfs_kdamond_ktype, &kdamonds->kobj,1732 "%d", i);1733 if (err)1734 goto out;1735 1736 err = damon_sysfs_kdamond_add_dirs(kdamond);1737 if (err)1738 goto out;1739 1740 kdamonds_arr[i] = kdamond;1741 kdamonds->nr++;1742 }1743 return 0;1744 1745out:1746 damon_sysfs_kdamonds_rm_dirs(kdamonds);1747 kobject_put(&kdamond->kobj);1748 return err;1749}1750 1751static ssize_t nr_kdamonds_show(struct kobject *kobj,1752 struct kobj_attribute *attr, char *buf)1753{1754 struct damon_sysfs_kdamonds *kdamonds = container_of(kobj,1755 struct damon_sysfs_kdamonds, kobj);1756 1757 return sysfs_emit(buf, "%d\n", kdamonds->nr);1758}1759 1760static ssize_t nr_kdamonds_store(struct kobject *kobj,1761 struct kobj_attribute *attr, const char *buf, size_t count)1762{1763 struct damon_sysfs_kdamonds *kdamonds;1764 int nr, err;1765 1766 err = kstrtoint(buf, 0, &nr);1767 if (err)1768 return err;1769 if (nr < 0)1770 return -EINVAL;1771 1772 kdamonds = container_of(kobj, struct damon_sysfs_kdamonds, kobj);1773 1774 if (!mutex_trylock(&damon_sysfs_lock))1775 return -EBUSY;1776 err = damon_sysfs_kdamonds_add_dirs(kdamonds, nr);1777 mutex_unlock(&damon_sysfs_lock);1778 if (err)1779 return err;1780 1781 return count;1782}1783 1784static void damon_sysfs_kdamonds_release(struct kobject *kobj)1785{1786 kfree(container_of(kobj, struct damon_sysfs_kdamonds, kobj));1787}1788 1789static struct kobj_attribute damon_sysfs_kdamonds_nr_attr =1790 __ATTR_RW_MODE(nr_kdamonds, 0600);1791 1792static struct attribute *damon_sysfs_kdamonds_attrs[] = {1793 &damon_sysfs_kdamonds_nr_attr.attr,1794 NULL,1795};1796ATTRIBUTE_GROUPS(damon_sysfs_kdamonds);1797 1798static const struct kobj_type damon_sysfs_kdamonds_ktype = {1799 .release = damon_sysfs_kdamonds_release,1800 .sysfs_ops = &kobj_sysfs_ops,1801 .default_groups = damon_sysfs_kdamonds_groups,1802};1803 1804/*1805 * damon user interface directory1806 */1807 1808struct damon_sysfs_ui_dir {1809 struct kobject kobj;1810 struct damon_sysfs_kdamonds *kdamonds;1811};1812 1813static struct damon_sysfs_ui_dir *damon_sysfs_ui_dir_alloc(void)1814{1815 return kzalloc(sizeof(struct damon_sysfs_ui_dir), GFP_KERNEL);1816}1817 1818static int damon_sysfs_ui_dir_add_dirs(struct damon_sysfs_ui_dir *ui_dir)1819{1820 struct damon_sysfs_kdamonds *kdamonds;1821 int err;1822 1823 kdamonds = damon_sysfs_kdamonds_alloc();1824 if (!kdamonds)1825 return -ENOMEM;1826 1827 err = kobject_init_and_add(&kdamonds->kobj,1828 &damon_sysfs_kdamonds_ktype, &ui_dir->kobj,1829 "kdamonds");1830 if (err) {1831 kobject_put(&kdamonds->kobj);1832 return err;1833 }1834 ui_dir->kdamonds = kdamonds;1835 return err;1836}1837 1838static void damon_sysfs_ui_dir_release(struct kobject *kobj)1839{1840 kfree(container_of(kobj, struct damon_sysfs_ui_dir, kobj));1841}1842 1843static struct attribute *damon_sysfs_ui_dir_attrs[] = {1844 NULL,1845};1846ATTRIBUTE_GROUPS(damon_sysfs_ui_dir);1847 1848static const struct kobj_type damon_sysfs_ui_dir_ktype = {1849 .release = damon_sysfs_ui_dir_release,1850 .sysfs_ops = &kobj_sysfs_ops,1851 .default_groups = damon_sysfs_ui_dir_groups,1852};1853 1854static int __init damon_sysfs_init(void)1855{1856 struct kobject *damon_sysfs_root;1857 struct damon_sysfs_ui_dir *admin;1858 int err;1859 1860 damon_sysfs_root = kobject_create_and_add("damon", mm_kobj);1861 if (!damon_sysfs_root)1862 return -ENOMEM;1863 1864 admin = damon_sysfs_ui_dir_alloc();1865 if (!admin) {1866 kobject_put(damon_sysfs_root);1867 return -ENOMEM;1868 }1869 err = kobject_init_and_add(&admin->kobj, &damon_sysfs_ui_dir_ktype,1870 damon_sysfs_root, "admin");1871 if (err)1872 goto out;1873 err = damon_sysfs_ui_dir_add_dirs(admin);1874 if (err)1875 goto out;1876 return 0;1877 1878out:1879 kobject_put(&admin->kobj);1880 kobject_put(damon_sysfs_root);1881 return err;1882}1883subsys_initcall(damon_sysfs_init);1884 1885#include "tests/sysfs-kunit.h"1886