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