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