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_obj(struct damon_sysfs_region); 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_obj(struct damon_sysfs_regions); 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_objs(*regions_arr, nr_regions, 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 bool obsolete; 216 }; 217 218 static struct damon_sysfs_target *damon_sysfs_target_alloc(void) 219 { 220 return kzalloc_obj(struct damon_sysfs_target); 221 } 222 223 static int damon_sysfs_target_add_dirs(struct damon_sysfs_target *target) 224 { 225 struct damon_sysfs_regions *regions = damon_sysfs_regions_alloc(); 226 int err; 227 228 if (!regions) 229 return -ENOMEM; 230 231 err = kobject_init_and_add(®ions->kobj, &damon_sysfs_regions_ktype, 232 &target->kobj, "regions"); 233 if (err) 234 kobject_put(®ions->kobj); 235 else 236 target->regions = regions; 237 return err; 238 } 239 240 static void damon_sysfs_target_rm_dirs(struct damon_sysfs_target *target) 241 { 242 damon_sysfs_regions_rm_dirs(target->regions); 243 kobject_put(&target->regions->kobj); 244 } 245 246 static ssize_t pid_target_show(struct kobject *kobj, 247 struct kobj_attribute *attr, char *buf) 248 { 249 struct damon_sysfs_target *target = container_of(kobj, 250 struct damon_sysfs_target, kobj); 251 252 return sysfs_emit(buf, "%d\n", target->pid); 253 } 254 255 static ssize_t pid_target_store(struct kobject *kobj, 256 struct kobj_attribute *attr, const char *buf, size_t count) 257 { 258 struct damon_sysfs_target *target = container_of(kobj, 259 struct damon_sysfs_target, kobj); 260 int err = kstrtoint(buf, 0, &target->pid); 261 262 if (err) 263 return -EINVAL; 264 return count; 265 } 266 267 static ssize_t obsolete_target_show(struct kobject *kobj, 268 struct kobj_attribute *attr, char *buf) 269 { 270 struct damon_sysfs_target *target = container_of(kobj, 271 struct damon_sysfs_target, kobj); 272 273 return sysfs_emit(buf, "%c\n", target->obsolete ? 'Y' : 'N'); 274 } 275 276 static ssize_t obsolete_target_store(struct kobject *kobj, 277 struct kobj_attribute *attr, const char *buf, size_t count) 278 { 279 struct damon_sysfs_target *target = container_of(kobj, 280 struct damon_sysfs_target, kobj); 281 bool obsolete; 282 int err = kstrtobool(buf, &obsolete); 283 284 if (err) 285 return err; 286 target->obsolete = obsolete; 287 return count; 288 } 289 290 static void damon_sysfs_target_release(struct kobject *kobj) 291 { 292 kfree(container_of(kobj, struct damon_sysfs_target, kobj)); 293 } 294 295 static struct kobj_attribute damon_sysfs_target_pid_attr = 296 __ATTR_RW_MODE(pid_target, 0600); 297 298 static struct kobj_attribute damon_sysfs_target_obsolete_attr = 299 __ATTR_RW_MODE(obsolete_target, 0600); 300 301 static struct attribute *damon_sysfs_target_attrs[] = { 302 &damon_sysfs_target_pid_attr.attr, 303 &damon_sysfs_target_obsolete_attr.attr, 304 NULL, 305 }; 306 ATTRIBUTE_GROUPS(damon_sysfs_target); 307 308 static const struct kobj_type damon_sysfs_target_ktype = { 309 .release = damon_sysfs_target_release, 310 .sysfs_ops = &kobj_sysfs_ops, 311 .default_groups = damon_sysfs_target_groups, 312 }; 313 314 /* 315 * targets directory 316 */ 317 318 struct damon_sysfs_targets { 319 struct kobject kobj; 320 struct damon_sysfs_target **targets_arr; 321 int nr; 322 }; 323 324 static struct damon_sysfs_targets *damon_sysfs_targets_alloc(void) 325 { 326 return kzalloc_obj(struct damon_sysfs_targets); 327 } 328 329 static void damon_sysfs_targets_rm_dirs(struct damon_sysfs_targets *targets) 330 { 331 struct damon_sysfs_target **targets_arr = targets->targets_arr; 332 int i; 333 334 for (i = 0; i < targets->nr; i++) { 335 damon_sysfs_target_rm_dirs(targets_arr[i]); 336 kobject_put(&targets_arr[i]->kobj); 337 } 338 targets->nr = 0; 339 kfree(targets_arr); 340 targets->targets_arr = NULL; 341 } 342 343 static int damon_sysfs_targets_add_dirs(struct damon_sysfs_targets *targets, 344 int nr_targets) 345 { 346 struct damon_sysfs_target **targets_arr, *target; 347 int err, i; 348 349 damon_sysfs_targets_rm_dirs(targets); 350 if (!nr_targets) 351 return 0; 352 353 targets_arr = kmalloc_objs(*targets_arr, nr_targets, 354 GFP_KERNEL | __GFP_NOWARN); 355 if (!targets_arr) 356 return -ENOMEM; 357 targets->targets_arr = targets_arr; 358 359 for (i = 0; i < nr_targets; i++) { 360 target = damon_sysfs_target_alloc(); 361 if (!target) { 362 damon_sysfs_targets_rm_dirs(targets); 363 return -ENOMEM; 364 } 365 366 err = kobject_init_and_add(&target->kobj, 367 &damon_sysfs_target_ktype, &targets->kobj, 368 "%d", i); 369 if (err) 370 goto out; 371 372 err = damon_sysfs_target_add_dirs(target); 373 if (err) 374 goto out; 375 376 targets_arr[i] = target; 377 targets->nr++; 378 } 379 return 0; 380 381 out: 382 damon_sysfs_targets_rm_dirs(targets); 383 kobject_put(&target->kobj); 384 return err; 385 } 386 387 static ssize_t nr_targets_show(struct kobject *kobj, 388 struct kobj_attribute *attr, char *buf) 389 { 390 struct damon_sysfs_targets *targets = container_of(kobj, 391 struct damon_sysfs_targets, kobj); 392 393 return sysfs_emit(buf, "%d\n", targets->nr); 394 } 395 396 static ssize_t nr_targets_store(struct kobject *kobj, 397 struct kobj_attribute *attr, const char *buf, size_t count) 398 { 399 struct damon_sysfs_targets *targets; 400 int nr, err = kstrtoint(buf, 0, &nr); 401 402 if (err) 403 return err; 404 if (nr < 0) 405 return -EINVAL; 406 407 targets = container_of(kobj, struct damon_sysfs_targets, kobj); 408 409 if (!mutex_trylock(&damon_sysfs_lock)) 410 return -EBUSY; 411 err = damon_sysfs_targets_add_dirs(targets, nr); 412 mutex_unlock(&damon_sysfs_lock); 413 if (err) 414 return err; 415 416 return count; 417 } 418 419 static void damon_sysfs_targets_release(struct kobject *kobj) 420 { 421 kfree(container_of(kobj, struct damon_sysfs_targets, kobj)); 422 } 423 424 static struct kobj_attribute damon_sysfs_targets_nr_attr = 425 __ATTR_RW_MODE(nr_targets, 0600); 426 427 static struct attribute *damon_sysfs_targets_attrs[] = { 428 &damon_sysfs_targets_nr_attr.attr, 429 NULL, 430 }; 431 ATTRIBUTE_GROUPS(damon_sysfs_targets); 432 433 static const struct kobj_type damon_sysfs_targets_ktype = { 434 .release = damon_sysfs_targets_release, 435 .sysfs_ops = &kobj_sysfs_ops, 436 .default_groups = damon_sysfs_targets_groups, 437 }; 438 439 /* 440 * intervals goal directory 441 */ 442 443 struct damon_sysfs_intervals_goal { 444 struct kobject kobj; 445 unsigned long access_bp; 446 unsigned long aggrs; 447 unsigned long min_sample_us; 448 unsigned long max_sample_us; 449 }; 450 451 static struct damon_sysfs_intervals_goal *damon_sysfs_intervals_goal_alloc( 452 unsigned long access_bp, unsigned long aggrs, 453 unsigned long min_sample_us, unsigned long max_sample_us) 454 { 455 struct damon_sysfs_intervals_goal *goal = kmalloc_obj(*goal); 456 457 if (!goal) 458 return NULL; 459 460 goal->kobj = (struct kobject){}; 461 goal->access_bp = access_bp; 462 goal->aggrs = aggrs; 463 goal->min_sample_us = min_sample_us; 464 goal->max_sample_us = max_sample_us; 465 return goal; 466 } 467 468 static ssize_t access_bp_show(struct kobject *kobj, 469 struct kobj_attribute *attr, char *buf) 470 { 471 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 472 struct damon_sysfs_intervals_goal, kobj); 473 474 return sysfs_emit(buf, "%lu\n", goal->access_bp); 475 } 476 477 static ssize_t access_bp_store(struct kobject *kobj, 478 struct kobj_attribute *attr, const char *buf, size_t count) 479 { 480 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 481 struct damon_sysfs_intervals_goal, kobj); 482 unsigned long nr; 483 int err = kstrtoul(buf, 0, &nr); 484 485 if (err) 486 return err; 487 488 goal->access_bp = nr; 489 return count; 490 } 491 492 static ssize_t aggrs_show(struct kobject *kobj, 493 struct kobj_attribute *attr, char *buf) 494 { 495 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 496 struct damon_sysfs_intervals_goal, kobj); 497 498 return sysfs_emit(buf, "%lu\n", goal->aggrs); 499 } 500 501 static ssize_t aggrs_store(struct kobject *kobj, 502 struct kobj_attribute *attr, const char *buf, size_t count) 503 { 504 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 505 struct damon_sysfs_intervals_goal, kobj); 506 unsigned long nr; 507 int err = kstrtoul(buf, 0, &nr); 508 509 if (err) 510 return err; 511 512 goal->aggrs = nr; 513 return count; 514 } 515 516 static ssize_t min_sample_us_show(struct kobject *kobj, 517 struct kobj_attribute *attr, char *buf) 518 { 519 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 520 struct damon_sysfs_intervals_goal, kobj); 521 522 return sysfs_emit(buf, "%lu\n", goal->min_sample_us); 523 } 524 525 static ssize_t min_sample_us_store(struct kobject *kobj, 526 struct kobj_attribute *attr, const char *buf, size_t count) 527 { 528 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 529 struct damon_sysfs_intervals_goal, kobj); 530 unsigned long nr; 531 int err = kstrtoul(buf, 0, &nr); 532 533 if (err) 534 return err; 535 536 goal->min_sample_us = nr; 537 return count; 538 } 539 540 static ssize_t max_sample_us_show(struct kobject *kobj, 541 struct kobj_attribute *attr, char *buf) 542 { 543 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 544 struct damon_sysfs_intervals_goal, kobj); 545 546 return sysfs_emit(buf, "%lu\n", goal->max_sample_us); 547 } 548 549 static ssize_t max_sample_us_store(struct kobject *kobj, 550 struct kobj_attribute *attr, const char *buf, size_t count) 551 { 552 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 553 struct damon_sysfs_intervals_goal, kobj); 554 unsigned long nr; 555 int err = kstrtoul(buf, 0, &nr); 556 557 if (err) 558 return err; 559 560 goal->max_sample_us = nr; 561 return count; 562 } 563 564 static void damon_sysfs_intervals_goal_release(struct kobject *kobj) 565 { 566 kfree(container_of(kobj, struct damon_sysfs_intervals_goal, kobj)); 567 } 568 569 static struct kobj_attribute damon_sysfs_intervals_goal_access_bp_attr = 570 __ATTR_RW_MODE(access_bp, 0600); 571 572 static struct kobj_attribute damon_sysfs_intervals_goal_aggrs_attr = 573 __ATTR_RW_MODE(aggrs, 0600); 574 575 static struct kobj_attribute damon_sysfs_intervals_goal_min_sample_us_attr = 576 __ATTR_RW_MODE(min_sample_us, 0600); 577 578 static struct kobj_attribute damon_sysfs_intervals_goal_max_sample_us_attr = 579 __ATTR_RW_MODE(max_sample_us, 0600); 580 581 static struct attribute *damon_sysfs_intervals_goal_attrs[] = { 582 &damon_sysfs_intervals_goal_access_bp_attr.attr, 583 &damon_sysfs_intervals_goal_aggrs_attr.attr, 584 &damon_sysfs_intervals_goal_min_sample_us_attr.attr, 585 &damon_sysfs_intervals_goal_max_sample_us_attr.attr, 586 NULL, 587 }; 588 ATTRIBUTE_GROUPS(damon_sysfs_intervals_goal); 589 590 static const struct kobj_type damon_sysfs_intervals_goal_ktype = { 591 .release = damon_sysfs_intervals_goal_release, 592 .sysfs_ops = &kobj_sysfs_ops, 593 .default_groups = damon_sysfs_intervals_goal_groups, 594 }; 595 596 /* 597 * intervals directory 598 */ 599 600 struct damon_sysfs_intervals { 601 struct kobject kobj; 602 unsigned long sample_us; 603 unsigned long aggr_us; 604 unsigned long update_us; 605 struct damon_sysfs_intervals_goal *intervals_goal; 606 }; 607 608 static struct damon_sysfs_intervals *damon_sysfs_intervals_alloc( 609 unsigned long sample_us, unsigned long aggr_us, 610 unsigned long update_us) 611 { 612 struct damon_sysfs_intervals *intervals = kmalloc_obj(*intervals); 613 614 if (!intervals) 615 return NULL; 616 617 intervals->kobj = (struct kobject){}; 618 intervals->sample_us = sample_us; 619 intervals->aggr_us = aggr_us; 620 intervals->update_us = update_us; 621 return intervals; 622 } 623 624 static int damon_sysfs_intervals_add_dirs(struct damon_sysfs_intervals *intervals) 625 { 626 struct damon_sysfs_intervals_goal *goal; 627 int err; 628 629 goal = damon_sysfs_intervals_goal_alloc(0, 0, 0, 0); 630 if (!goal) 631 return -ENOMEM; 632 633 err = kobject_init_and_add(&goal->kobj, 634 &damon_sysfs_intervals_goal_ktype, &intervals->kobj, 635 "intervals_goal"); 636 if (err) { 637 kobject_put(&goal->kobj); 638 intervals->intervals_goal = NULL; 639 return err; 640 } 641 intervals->intervals_goal = goal; 642 return 0; 643 } 644 645 static void damon_sysfs_intervals_rm_dirs(struct damon_sysfs_intervals *intervals) 646 { 647 kobject_put(&intervals->intervals_goal->kobj); 648 } 649 650 static ssize_t sample_us_show(struct kobject *kobj, 651 struct kobj_attribute *attr, char *buf) 652 { 653 struct damon_sysfs_intervals *intervals = container_of(kobj, 654 struct damon_sysfs_intervals, kobj); 655 656 return sysfs_emit(buf, "%lu\n", intervals->sample_us); 657 } 658 659 static ssize_t sample_us_store(struct kobject *kobj, 660 struct kobj_attribute *attr, const char *buf, size_t count) 661 { 662 struct damon_sysfs_intervals *intervals = container_of(kobj, 663 struct damon_sysfs_intervals, kobj); 664 unsigned long us; 665 int err = kstrtoul(buf, 0, &us); 666 667 if (err) 668 return err; 669 670 intervals->sample_us = us; 671 return count; 672 } 673 674 static ssize_t aggr_us_show(struct kobject *kobj, struct kobj_attribute *attr, 675 char *buf) 676 { 677 struct damon_sysfs_intervals *intervals = container_of(kobj, 678 struct damon_sysfs_intervals, kobj); 679 680 return sysfs_emit(buf, "%lu\n", intervals->aggr_us); 681 } 682 683 static ssize_t aggr_us_store(struct kobject *kobj, struct kobj_attribute *attr, 684 const char *buf, size_t count) 685 { 686 struct damon_sysfs_intervals *intervals = container_of(kobj, 687 struct damon_sysfs_intervals, kobj); 688 unsigned long us; 689 int err = kstrtoul(buf, 0, &us); 690 691 if (err) 692 return err; 693 694 intervals->aggr_us = us; 695 return count; 696 } 697 698 static ssize_t update_us_show(struct kobject *kobj, 699 struct kobj_attribute *attr, char *buf) 700 { 701 struct damon_sysfs_intervals *intervals = container_of(kobj, 702 struct damon_sysfs_intervals, kobj); 703 704 return sysfs_emit(buf, "%lu\n", intervals->update_us); 705 } 706 707 static ssize_t update_us_store(struct kobject *kobj, 708 struct kobj_attribute *attr, const char *buf, size_t count) 709 { 710 struct damon_sysfs_intervals *intervals = container_of(kobj, 711 struct damon_sysfs_intervals, kobj); 712 unsigned long us; 713 int err = kstrtoul(buf, 0, &us); 714 715 if (err) 716 return err; 717 718 intervals->update_us = us; 719 return count; 720 } 721 722 static void damon_sysfs_intervals_release(struct kobject *kobj) 723 { 724 kfree(container_of(kobj, struct damon_sysfs_intervals, kobj)); 725 } 726 727 static struct kobj_attribute damon_sysfs_intervals_sample_us_attr = 728 __ATTR_RW_MODE(sample_us, 0600); 729 730 static struct kobj_attribute damon_sysfs_intervals_aggr_us_attr = 731 __ATTR_RW_MODE(aggr_us, 0600); 732 733 static struct kobj_attribute damon_sysfs_intervals_update_us_attr = 734 __ATTR_RW_MODE(update_us, 0600); 735 736 static struct attribute *damon_sysfs_intervals_attrs[] = { 737 &damon_sysfs_intervals_sample_us_attr.attr, 738 &damon_sysfs_intervals_aggr_us_attr.attr, 739 &damon_sysfs_intervals_update_us_attr.attr, 740 NULL, 741 }; 742 ATTRIBUTE_GROUPS(damon_sysfs_intervals); 743 744 static const struct kobj_type damon_sysfs_intervals_ktype = { 745 .release = damon_sysfs_intervals_release, 746 .sysfs_ops = &kobj_sysfs_ops, 747 .default_groups = damon_sysfs_intervals_groups, 748 }; 749 750 /* 751 * filter directory 752 */ 753 754 struct damon_sysfs_filter { 755 struct kobject kobj; 756 enum damon_filter_type type; 757 bool matching; 758 bool allow; 759 }; 760 761 static struct damon_sysfs_filter *damon_sysfs_filter_alloc(void) 762 { 763 return kzalloc_obj(struct damon_sysfs_filter); 764 } 765 766 struct damon_sysfs_filter_type_name { 767 enum damon_filter_type type; 768 char *name; 769 }; 770 771 static const struct damon_sysfs_filter_type_name 772 damon_sysfs_filter_type_names[] = { 773 { 774 .type = DAMON_FILTER_TYPE_ANON, 775 .name = "anon", 776 }, 777 }; 778 779 static ssize_t type_show(struct kobject *kobj, 780 struct kobj_attribute *attr, char *buf) 781 { 782 struct damon_sysfs_filter *filter = container_of(kobj, 783 struct damon_sysfs_filter, kobj); 784 int i; 785 786 for (i = 0; i < ARRAY_SIZE(damon_sysfs_filter_type_names); i++) { 787 const struct damon_sysfs_filter_type_name *type_name; 788 789 type_name = &damon_sysfs_filter_type_names[i]; 790 if (type_name->type == filter->type) 791 return sysfs_emit(buf, "%s\n", type_name->name); 792 } 793 return -EINVAL; 794 } 795 796 static ssize_t type_store(struct kobject *kobj, 797 struct kobj_attribute *attr, const char *buf, size_t count) 798 { 799 struct damon_sysfs_filter *filter = container_of(kobj, 800 struct damon_sysfs_filter, kobj); 801 ssize_t ret = -EINVAL; 802 int i; 803 804 for (i = 0; i < ARRAY_SIZE(damon_sysfs_filter_type_names); i++) { 805 const struct damon_sysfs_filter_type_name *type_name; 806 807 type_name = &damon_sysfs_filter_type_names[i]; 808 if (sysfs_streq(buf, type_name->name)) { 809 filter->type = type_name->type; 810 ret = count; 811 break; 812 } 813 } 814 return ret; 815 } 816 817 static ssize_t matching_show(struct kobject *kobj, 818 struct kobj_attribute *attr, char *buf) 819 { 820 struct damon_sysfs_filter *filter = container_of(kobj, 821 struct damon_sysfs_filter, kobj); 822 823 return sysfs_emit(buf, "%c\n", filter->matching ? 'Y' : 'N'); 824 } 825 826 static ssize_t matching_store(struct kobject *kobj, 827 struct kobj_attribute *attr, const char *buf, size_t count) 828 { 829 struct damon_sysfs_filter *filter = container_of(kobj, 830 struct damon_sysfs_filter, kobj); 831 bool matching; 832 int err = kstrtobool(buf, &matching); 833 834 if (err) 835 return err; 836 837 filter->matching = matching; 838 return count; 839 } 840 841 static ssize_t allow_show(struct kobject *kobj, 842 struct kobj_attribute *attr, char *buf) 843 { 844 struct damon_sysfs_filter *filter = container_of(kobj, 845 struct damon_sysfs_filter, kobj); 846 847 return sysfs_emit(buf, "%c\n", filter->allow ? 'Y' : 'N'); 848 } 849 850 static ssize_t allow_store(struct kobject *kobj, 851 struct kobj_attribute *attr, const char *buf, size_t count) 852 { 853 struct damon_sysfs_filter *filter = container_of(kobj, 854 struct damon_sysfs_filter, kobj); 855 bool allow; 856 int err = kstrtobool(buf, &allow); 857 858 if (err) 859 return err; 860 861 filter->allow = allow; 862 return count; 863 } 864 865 static void damon_sysfs_filter_release(struct kobject *kobj) 866 { 867 struct damon_sysfs_filter *filter = container_of(kobj, 868 struct damon_sysfs_filter, kobj); 869 870 kfree(filter); 871 } 872 873 static struct kobj_attribute damon_sysfs_filter_type_attr = 874 __ATTR_RW_MODE(type, 0600); 875 876 static struct kobj_attribute damon_sysfs_filter_matching_attr = 877 __ATTR_RW_MODE(matching, 0600); 878 879 static struct kobj_attribute damon_sysfs_filter_allow_attr = 880 __ATTR_RW_MODE(allow, 0600); 881 882 static struct attribute *damon_sysfs_filter_attrs[] = { 883 &damon_sysfs_filter_type_attr.attr, 884 &damon_sysfs_filter_matching_attr.attr, 885 &damon_sysfs_filter_allow_attr.attr, 886 NULL, 887 }; 888 ATTRIBUTE_GROUPS(damon_sysfs_filter); 889 890 static const struct kobj_type damon_sysfs_filter_ktype = { 891 .release = damon_sysfs_filter_release, 892 .sysfs_ops = &kobj_sysfs_ops, 893 .default_groups = damon_sysfs_filter_groups, 894 }; 895 896 /* 897 * filters directory 898 */ 899 900 struct damon_sysfs_filters { 901 struct kobject kobj; 902 struct damon_sysfs_filter **filters_arr; 903 int nr; 904 }; 905 906 static struct damon_sysfs_filters *damon_sysfs_filters_alloc(void) 907 { 908 return kzalloc_obj(struct damon_sysfs_filters); 909 } 910 911 static void damon_sysfs_filters_rm_dirs(struct damon_sysfs_filters *filters) 912 { 913 struct damon_sysfs_filter **filters_arr = filters->filters_arr; 914 int i; 915 916 for (i = 0; i < filters->nr; i++) 917 kobject_put(&filters_arr[i]->kobj); 918 filters->nr = 0; 919 kfree(filters_arr); 920 filters->filters_arr = NULL; 921 } 922 923 static int damon_sysfs_filters_add_dirs( 924 struct damon_sysfs_filters *filters, int nr_filters) 925 { 926 struct damon_sysfs_filter **filters_arr, *filter; 927 int err, i; 928 929 damon_sysfs_filters_rm_dirs(filters); 930 if (!nr_filters) 931 return 0; 932 933 filters_arr = kmalloc_objs(*filters_arr, nr_filters, 934 GFP_KERNEL | __GFP_NOWARN); 935 if (!filters_arr) 936 return -ENOMEM; 937 filters->filters_arr = filters_arr; 938 939 for (i = 0; i < nr_filters; i++) { 940 filter = damon_sysfs_filter_alloc(); 941 if (!filter) { 942 damon_sysfs_filters_rm_dirs(filters); 943 return -ENOMEM; 944 } 945 946 err = kobject_init_and_add(&filter->kobj, 947 &damon_sysfs_filter_ktype, &filters->kobj, 948 "%d", i); 949 if (err) { 950 kobject_put(&filter->kobj); 951 damon_sysfs_filters_rm_dirs(filters); 952 return err; 953 } 954 955 filters_arr[i] = filter; 956 filters->nr++; 957 } 958 return 0; 959 } 960 961 static ssize_t nr_filters_show(struct kobject *kobj, 962 struct kobj_attribute *attr, char *buf) 963 { 964 struct damon_sysfs_filters *filters = container_of(kobj, 965 struct damon_sysfs_filters, kobj); 966 967 return sysfs_emit(buf, "%d\n", filters->nr); 968 } 969 970 static ssize_t nr_filters_store(struct kobject *kobj, 971 struct kobj_attribute *attr, const char *buf, size_t count) 972 { 973 struct damon_sysfs_filters *filters; 974 int nr, err = kstrtoint(buf, 0, &nr); 975 976 if (err) 977 return err; 978 if (nr < 0) 979 return -EINVAL; 980 981 filters = container_of(kobj, struct damon_sysfs_filters, kobj); 982 983 if (!mutex_trylock(&damon_sysfs_lock)) 984 return -EBUSY; 985 err = damon_sysfs_filters_add_dirs(filters, nr); 986 mutex_unlock(&damon_sysfs_lock); 987 if (err) 988 return err; 989 990 return count; 991 } 992 993 static void damon_sysfs_filters_release(struct kobject *kobj) 994 { 995 kfree(container_of(kobj, struct damon_sysfs_filters, kobj)); 996 } 997 998 static struct kobj_attribute damon_sysfs_filters_nr_attr = 999 __ATTR_RW_MODE(nr_filters, 0600); 1000 1001 static struct attribute *damon_sysfs_filters_attrs[] = { 1002 &damon_sysfs_filters_nr_attr.attr, 1003 NULL, 1004 }; 1005 ATTRIBUTE_GROUPS(damon_sysfs_filters); 1006 1007 static const struct kobj_type damon_sysfs_filters_ktype = { 1008 .release = damon_sysfs_filters_release, 1009 .sysfs_ops = &kobj_sysfs_ops, 1010 .default_groups = damon_sysfs_filters_groups, 1011 }; 1012 1013 /* 1014 * probe directory 1015 */ 1016 1017 struct damon_sysfs_probe { 1018 struct kobject kobj; 1019 struct damon_sysfs_filters *filters; 1020 }; 1021 1022 static struct damon_sysfs_probe *damon_sysfs_probe_alloc(void) 1023 { 1024 return kzalloc_obj(struct damon_sysfs_probe); 1025 } 1026 1027 static int damon_sysfs_probe_add_dirs(struct damon_sysfs_probe *attr) 1028 { 1029 struct damon_sysfs_filters *filters; 1030 int err; 1031 1032 filters = damon_sysfs_filters_alloc(); 1033 if (!filters) 1034 return -ENOMEM; 1035 attr->filters = filters; 1036 1037 err = kobject_init_and_add(&filters->kobj, &damon_sysfs_filters_ktype, 1038 &attr->kobj, "filters"); 1039 if (err) { 1040 kobject_put(&filters->kobj); 1041 attr->filters = NULL; 1042 } 1043 return err; 1044 } 1045 1046 static void damon_sysfs_probe_rm_dirs(struct damon_sysfs_probe *attr) 1047 { 1048 if (attr->filters) { 1049 damon_sysfs_filters_rm_dirs(attr->filters); 1050 kobject_put(&attr->filters->kobj); 1051 } 1052 } 1053 1054 static void damon_sysfs_probe_release(struct kobject *kobj) 1055 { 1056 kfree(container_of(kobj, struct damon_sysfs_probe, kobj)); 1057 } 1058 1059 static struct attribute *damon_sysfs_probe_attrs[] = { 1060 NULL, 1061 }; 1062 ATTRIBUTE_GROUPS(damon_sysfs_probe); 1063 1064 static const struct kobj_type damon_sysfs_probe_ktype = { 1065 .release = damon_sysfs_probe_release, 1066 .sysfs_ops = &kobj_sysfs_ops, 1067 .default_groups = damon_sysfs_probe_groups, 1068 }; 1069 1070 /* 1071 * probes directory 1072 */ 1073 1074 struct damon_sysfs_probes { 1075 struct kobject kobj; 1076 struct damon_sysfs_probe **probes_arr; 1077 int nr; 1078 }; 1079 1080 static struct damon_sysfs_probes *damon_sysfs_probes_alloc(void) 1081 { 1082 return kzalloc_obj(struct damon_sysfs_probes); 1083 } 1084 1085 static void damon_sysfs_probes_rm_dirs( 1086 struct damon_sysfs_probes *probes) 1087 { 1088 struct damon_sysfs_probe **probes_arr = probes->probes_arr; 1089 int i; 1090 1091 for (i = 0; i < probes->nr; i++) { 1092 damon_sysfs_probe_rm_dirs(probes_arr[i]); 1093 kobject_put(&probes_arr[i]->kobj); 1094 } 1095 probes->nr = 0; 1096 kfree(probes_arr); 1097 probes->probes_arr = NULL; 1098 } 1099 1100 static int damon_sysfs_probes_add_dirs( 1101 struct damon_sysfs_probes *probes, int nr_probes) 1102 { 1103 struct damon_sysfs_probe **probes_arr, *probe; 1104 int err, i; 1105 1106 damon_sysfs_probes_rm_dirs(probes); 1107 if (!nr_probes) 1108 return 0; 1109 1110 probes_arr = kmalloc_objs(*probes_arr, nr_probes, 1111 GFP_KERNEL | __GFP_NOWARN); 1112 if (!probes_arr) 1113 return -ENOMEM; 1114 probes->probes_arr = probes_arr; 1115 1116 for (i = 0; i < nr_probes; i++) { 1117 probe = damon_sysfs_probe_alloc(); 1118 if (!probe) { 1119 damon_sysfs_probes_rm_dirs(probes); 1120 return -ENOMEM; 1121 } 1122 1123 err = kobject_init_and_add(&probe->kobj, 1124 &damon_sysfs_probe_ktype, &probes->kobj, 1125 "%d", i); 1126 if (err) { 1127 kobject_put(&probe->kobj); 1128 damon_sysfs_probes_rm_dirs(probes); 1129 return err; 1130 } 1131 1132 err = damon_sysfs_probe_add_dirs(probe); 1133 if (err) { 1134 kobject_put(&probe->kobj); 1135 damon_sysfs_probes_rm_dirs(probes); 1136 return err; 1137 } 1138 1139 probes_arr[i] = probe; 1140 probes->nr++; 1141 } 1142 return 0; 1143 } 1144 1145 static ssize_t nr_probes_show(struct kobject *kobj, 1146 struct kobj_attribute *attr, char *buf) 1147 { 1148 struct damon_sysfs_probes *probes = container_of(kobj, 1149 struct damon_sysfs_probes, kobj); 1150 1151 return sysfs_emit(buf, "%d\n", probes->nr); 1152 } 1153 1154 static ssize_t nr_probes_store(struct kobject *kobj, 1155 struct kobj_attribute *attr, const char *buf, size_t count) 1156 { 1157 struct damon_sysfs_probes *probes; 1158 int nr, err = kstrtoint(buf, 0, &nr); 1159 1160 if (err) 1161 return err; 1162 if (nr < 0 || nr > DAMON_MAX_PROBES) 1163 return -EINVAL; 1164 1165 probes = container_of(kobj, struct damon_sysfs_probes, kobj); 1166 1167 if (!mutex_trylock(&damon_sysfs_lock)) 1168 return -EBUSY; 1169 err = damon_sysfs_probes_add_dirs(probes, nr); 1170 mutex_unlock(&damon_sysfs_lock); 1171 if (err) 1172 return err; 1173 1174 return count; 1175 } 1176 1177 static void damon_sysfs_probes_release(struct kobject *kobj) 1178 { 1179 kfree(container_of(kobj, struct damon_sysfs_probes, kobj)); 1180 } 1181 1182 static struct kobj_attribute damon_sysfs_probes_nr_probes = 1183 __ATTR_RW_MODE(nr_probes, 0600); 1184 1185 static struct attribute *damon_sysfs_probes_attrs[] = { 1186 &damon_sysfs_probes_nr_probes.attr, 1187 NULL, 1188 }; 1189 ATTRIBUTE_GROUPS(damon_sysfs_probes); 1190 1191 static const struct kobj_type damon_sysfs_probes_ktype = { 1192 .release = damon_sysfs_probes_release, 1193 .sysfs_ops = &kobj_sysfs_ops, 1194 .default_groups = damon_sysfs_probes_groups, 1195 }; 1196 1197 /* 1198 * monitoring_attrs directory 1199 */ 1200 1201 struct damon_sysfs_attrs { 1202 struct kobject kobj; 1203 struct damon_sysfs_intervals *intervals; 1204 struct damon_sysfs_ul_range *nr_regions_range; 1205 struct damon_sysfs_probes *probes; 1206 }; 1207 1208 static struct damon_sysfs_attrs *damon_sysfs_attrs_alloc(void) 1209 { 1210 struct damon_sysfs_attrs *attrs = kmalloc_obj(*attrs); 1211 1212 if (!attrs) 1213 return NULL; 1214 attrs->kobj = (struct kobject){}; 1215 return attrs; 1216 } 1217 1218 static int damon_sysfs_attrs_add_dirs(struct damon_sysfs_attrs *attrs) 1219 { 1220 struct damon_sysfs_intervals *intervals; 1221 struct damon_sysfs_ul_range *nr_regions_range; 1222 struct damon_sysfs_probes *probes; 1223 int err; 1224 1225 intervals = damon_sysfs_intervals_alloc(5000, 100000, 60000000); 1226 if (!intervals) 1227 return -ENOMEM; 1228 1229 err = kobject_init_and_add(&intervals->kobj, 1230 &damon_sysfs_intervals_ktype, &attrs->kobj, 1231 "intervals"); 1232 if (err) 1233 goto put_intervals_out; 1234 err = damon_sysfs_intervals_add_dirs(intervals); 1235 if (err) 1236 goto put_intervals_out; 1237 attrs->intervals = intervals; 1238 1239 nr_regions_range = damon_sysfs_ul_range_alloc(10, 1000); 1240 if (!nr_regions_range) { 1241 err = -ENOMEM; 1242 goto rmdir_put_intervals_out; 1243 } 1244 1245 err = kobject_init_and_add(&nr_regions_range->kobj, 1246 &damon_sysfs_ul_range_ktype, &attrs->kobj, 1247 "nr_regions"); 1248 if (err) 1249 goto put_nr_regions_intervals_out; 1250 attrs->nr_regions_range = nr_regions_range; 1251 1252 probes = damon_sysfs_probes_alloc(); 1253 if (!probes) { 1254 err = -ENOMEM; 1255 goto put_nr_regions_intervals_out; 1256 } 1257 err = kobject_init_and_add(&probes->kobj, 1258 &damon_sysfs_probes_ktype, &attrs->kobj, "probes"); 1259 if (err) 1260 goto put_probes_out; 1261 attrs->probes = probes; 1262 return 0; 1263 1264 put_probes_out: 1265 kobject_put(&probes->kobj); 1266 attrs->probes = NULL; 1267 put_nr_regions_intervals_out: 1268 kobject_put(&nr_regions_range->kobj); 1269 attrs->nr_regions_range = NULL; 1270 rmdir_put_intervals_out: 1271 damon_sysfs_intervals_rm_dirs(intervals); 1272 put_intervals_out: 1273 kobject_put(&intervals->kobj); 1274 attrs->intervals = NULL; 1275 return err; 1276 } 1277 1278 static void damon_sysfs_attrs_rm_dirs(struct damon_sysfs_attrs *attrs) 1279 { 1280 kobject_put(&attrs->nr_regions_range->kobj); 1281 damon_sysfs_intervals_rm_dirs(attrs->intervals); 1282 kobject_put(&attrs->intervals->kobj); 1283 damon_sysfs_probes_rm_dirs(attrs->probes); 1284 kobject_put(&attrs->probes->kobj); 1285 } 1286 1287 static void damon_sysfs_attrs_release(struct kobject *kobj) 1288 { 1289 kfree(container_of(kobj, struct damon_sysfs_attrs, kobj)); 1290 } 1291 1292 static struct attribute *damon_sysfs_attrs_attrs[] = { 1293 NULL, 1294 }; 1295 ATTRIBUTE_GROUPS(damon_sysfs_attrs); 1296 1297 static const struct kobj_type damon_sysfs_attrs_ktype = { 1298 .release = damon_sysfs_attrs_release, 1299 .sysfs_ops = &kobj_sysfs_ops, 1300 .default_groups = damon_sysfs_attrs_groups, 1301 }; 1302 1303 /* 1304 * context directory 1305 */ 1306 1307 struct damon_sysfs_ops_name { 1308 enum damon_ops_id ops_id; 1309 char *name; 1310 }; 1311 1312 static const struct damon_sysfs_ops_name damon_sysfs_ops_names[] = { 1313 { 1314 .ops_id = DAMON_OPS_VADDR, 1315 .name = "vaddr", 1316 }, 1317 { 1318 .ops_id = DAMON_OPS_FVADDR, 1319 .name = "fvaddr", 1320 }, 1321 { 1322 .ops_id = DAMON_OPS_PADDR, 1323 .name = "paddr", 1324 }, 1325 }; 1326 1327 struct damon_sysfs_context { 1328 struct kobject kobj; 1329 enum damon_ops_id ops_id; 1330 unsigned long addr_unit; 1331 struct damon_sysfs_attrs *attrs; 1332 struct damon_sysfs_targets *targets; 1333 struct damon_sysfs_schemes *schemes; 1334 bool pause; 1335 }; 1336 1337 static struct damon_sysfs_context *damon_sysfs_context_alloc( 1338 enum damon_ops_id ops_id) 1339 { 1340 struct damon_sysfs_context *context = kmalloc_obj(*context); 1341 1342 if (!context) 1343 return NULL; 1344 context->kobj = (struct kobject){}; 1345 context->ops_id = ops_id; 1346 context->addr_unit = 1; 1347 context->pause = false; 1348 return context; 1349 } 1350 1351 static int damon_sysfs_context_set_attrs(struct damon_sysfs_context *context) 1352 { 1353 struct damon_sysfs_attrs *attrs = damon_sysfs_attrs_alloc(); 1354 int err; 1355 1356 if (!attrs) 1357 return -ENOMEM; 1358 err = kobject_init_and_add(&attrs->kobj, &damon_sysfs_attrs_ktype, 1359 &context->kobj, "monitoring_attrs"); 1360 if (err) 1361 goto out; 1362 err = damon_sysfs_attrs_add_dirs(attrs); 1363 if (err) 1364 goto out; 1365 context->attrs = attrs; 1366 return 0; 1367 1368 out: 1369 kobject_put(&attrs->kobj); 1370 return err; 1371 } 1372 1373 static int damon_sysfs_context_set_targets(struct damon_sysfs_context *context) 1374 { 1375 struct damon_sysfs_targets *targets = damon_sysfs_targets_alloc(); 1376 int err; 1377 1378 if (!targets) 1379 return -ENOMEM; 1380 err = kobject_init_and_add(&targets->kobj, &damon_sysfs_targets_ktype, 1381 &context->kobj, "targets"); 1382 if (err) { 1383 kobject_put(&targets->kobj); 1384 return err; 1385 } 1386 context->targets = targets; 1387 return 0; 1388 } 1389 1390 static int damon_sysfs_context_set_schemes(struct damon_sysfs_context *context) 1391 { 1392 struct damon_sysfs_schemes *schemes = damon_sysfs_schemes_alloc(); 1393 int err; 1394 1395 if (!schemes) 1396 return -ENOMEM; 1397 err = kobject_init_and_add(&schemes->kobj, &damon_sysfs_schemes_ktype, 1398 &context->kobj, "schemes"); 1399 if (err) { 1400 kobject_put(&schemes->kobj); 1401 return err; 1402 } 1403 context->schemes = schemes; 1404 return 0; 1405 } 1406 1407 static int damon_sysfs_context_add_dirs(struct damon_sysfs_context *context) 1408 { 1409 int err; 1410 1411 err = damon_sysfs_context_set_attrs(context); 1412 if (err) 1413 return err; 1414 1415 err = damon_sysfs_context_set_targets(context); 1416 if (err) 1417 goto rmdir_put_attrs_out; 1418 1419 err = damon_sysfs_context_set_schemes(context); 1420 if (err) 1421 goto put_targets_attrs_out; 1422 return 0; 1423 1424 put_targets_attrs_out: 1425 kobject_put(&context->targets->kobj); 1426 context->targets = NULL; 1427 rmdir_put_attrs_out: 1428 damon_sysfs_attrs_rm_dirs(context->attrs); 1429 kobject_put(&context->attrs->kobj); 1430 context->attrs = NULL; 1431 return err; 1432 } 1433 1434 static void damon_sysfs_context_rm_dirs(struct damon_sysfs_context *context) 1435 { 1436 damon_sysfs_attrs_rm_dirs(context->attrs); 1437 kobject_put(&context->attrs->kobj); 1438 damon_sysfs_targets_rm_dirs(context->targets); 1439 kobject_put(&context->targets->kobj); 1440 damon_sysfs_schemes_rm_dirs(context->schemes); 1441 kobject_put(&context->schemes->kobj); 1442 } 1443 1444 static ssize_t avail_operations_show(struct kobject *kobj, 1445 struct kobj_attribute *attr, char *buf) 1446 { 1447 int len = 0; 1448 int i; 1449 1450 for (i = 0; i < ARRAY_SIZE(damon_sysfs_ops_names); i++) { 1451 const struct damon_sysfs_ops_name *ops_name; 1452 1453 ops_name = &damon_sysfs_ops_names[i]; 1454 if (!damon_is_registered_ops(ops_name->ops_id)) 1455 continue; 1456 len += sysfs_emit_at(buf, len, "%s\n", ops_name->name); 1457 } 1458 return len; 1459 } 1460 1461 static ssize_t operations_show(struct kobject *kobj, 1462 struct kobj_attribute *attr, char *buf) 1463 { 1464 struct damon_sysfs_context *context = container_of(kobj, 1465 struct damon_sysfs_context, kobj); 1466 int i; 1467 1468 for (i = 0; i < ARRAY_SIZE(damon_sysfs_ops_names); i++) { 1469 const struct damon_sysfs_ops_name *ops_name; 1470 1471 ops_name = &damon_sysfs_ops_names[i]; 1472 if (ops_name->ops_id == context->ops_id) 1473 return sysfs_emit(buf, "%s\n", ops_name->name); 1474 } 1475 return -EINVAL; 1476 } 1477 1478 static ssize_t operations_store(struct kobject *kobj, 1479 struct kobj_attribute *attr, const char *buf, size_t count) 1480 { 1481 struct damon_sysfs_context *context = container_of(kobj, 1482 struct damon_sysfs_context, kobj); 1483 int i; 1484 1485 for (i = 0; i < ARRAY_SIZE(damon_sysfs_ops_names); i++) { 1486 const struct damon_sysfs_ops_name *ops_name; 1487 1488 ops_name = &damon_sysfs_ops_names[i]; 1489 if (sysfs_streq(buf, ops_name->name)) { 1490 context->ops_id = ops_name->ops_id; 1491 return count; 1492 } 1493 } 1494 return -EINVAL; 1495 } 1496 1497 static ssize_t addr_unit_show(struct kobject *kobj, 1498 struct kobj_attribute *attr, char *buf) 1499 { 1500 struct damon_sysfs_context *context = container_of(kobj, 1501 struct damon_sysfs_context, kobj); 1502 1503 return sysfs_emit(buf, "%lu\n", context->addr_unit); 1504 } 1505 1506 static ssize_t addr_unit_store(struct kobject *kobj, 1507 struct kobj_attribute *attr, const char *buf, size_t count) 1508 { 1509 struct damon_sysfs_context *context = container_of(kobj, 1510 struct damon_sysfs_context, kobj); 1511 unsigned long input_addr_unit; 1512 int err = kstrtoul(buf, 0, &input_addr_unit); 1513 1514 if (err) 1515 return err; 1516 if (!input_addr_unit) 1517 return -EINVAL; 1518 1519 context->addr_unit = input_addr_unit; 1520 return count; 1521 } 1522 1523 static ssize_t pause_show(struct kobject *kobj, struct kobj_attribute *attr, 1524 char *buf) 1525 { 1526 struct damon_sysfs_context *context = container_of(kobj, 1527 struct damon_sysfs_context, kobj); 1528 1529 return sysfs_emit(buf, "%c\n", context->pause ? 'Y' : 'N'); 1530 } 1531 1532 static ssize_t pause_store(struct kobject *kobj, struct kobj_attribute *attr, 1533 const char *buf, size_t count) 1534 { 1535 struct damon_sysfs_context *context = container_of(kobj, 1536 struct damon_sysfs_context, kobj); 1537 bool pause; 1538 int err = kstrtobool(buf, &pause); 1539 1540 if (err) 1541 return err; 1542 context->pause = pause; 1543 return count; 1544 } 1545 1546 1547 static void damon_sysfs_context_release(struct kobject *kobj) 1548 { 1549 kfree(container_of(kobj, struct damon_sysfs_context, kobj)); 1550 } 1551 1552 static struct kobj_attribute damon_sysfs_context_avail_operations_attr = 1553 __ATTR_RO_MODE(avail_operations, 0400); 1554 1555 static struct kobj_attribute damon_sysfs_context_operations_attr = 1556 __ATTR_RW_MODE(operations, 0600); 1557 1558 static struct kobj_attribute damon_sysfs_context_addr_unit_attr = 1559 __ATTR_RW_MODE(addr_unit, 0600); 1560 1561 static struct kobj_attribute damon_sysfs_context_pause_attr = 1562 __ATTR_RW_MODE(pause, 0600); 1563 1564 static struct attribute *damon_sysfs_context_attrs[] = { 1565 &damon_sysfs_context_avail_operations_attr.attr, 1566 &damon_sysfs_context_operations_attr.attr, 1567 &damon_sysfs_context_addr_unit_attr.attr, 1568 &damon_sysfs_context_pause_attr.attr, 1569 NULL, 1570 }; 1571 ATTRIBUTE_GROUPS(damon_sysfs_context); 1572 1573 static const struct kobj_type damon_sysfs_context_ktype = { 1574 .release = damon_sysfs_context_release, 1575 .sysfs_ops = &kobj_sysfs_ops, 1576 .default_groups = damon_sysfs_context_groups, 1577 }; 1578 1579 /* 1580 * contexts directory 1581 */ 1582 1583 struct damon_sysfs_contexts { 1584 struct kobject kobj; 1585 struct damon_sysfs_context **contexts_arr; 1586 int nr; 1587 }; 1588 1589 static struct damon_sysfs_contexts *damon_sysfs_contexts_alloc(void) 1590 { 1591 return kzalloc_obj(struct damon_sysfs_contexts); 1592 } 1593 1594 static void damon_sysfs_contexts_rm_dirs(struct damon_sysfs_contexts *contexts) 1595 { 1596 struct damon_sysfs_context **contexts_arr = contexts->contexts_arr; 1597 int i; 1598 1599 for (i = 0; i < contexts->nr; i++) { 1600 damon_sysfs_context_rm_dirs(contexts_arr[i]); 1601 kobject_put(&contexts_arr[i]->kobj); 1602 } 1603 contexts->nr = 0; 1604 kfree(contexts_arr); 1605 contexts->contexts_arr = NULL; 1606 } 1607 1608 static int damon_sysfs_contexts_add_dirs(struct damon_sysfs_contexts *contexts, 1609 int nr_contexts) 1610 { 1611 struct damon_sysfs_context **contexts_arr, *context; 1612 int err, i; 1613 1614 damon_sysfs_contexts_rm_dirs(contexts); 1615 if (!nr_contexts) 1616 return 0; 1617 1618 contexts_arr = kmalloc_objs(*contexts_arr, nr_contexts, 1619 GFP_KERNEL | __GFP_NOWARN); 1620 if (!contexts_arr) 1621 return -ENOMEM; 1622 contexts->contexts_arr = contexts_arr; 1623 1624 for (i = 0; i < nr_contexts; i++) { 1625 context = damon_sysfs_context_alloc(DAMON_OPS_VADDR); 1626 if (!context) { 1627 damon_sysfs_contexts_rm_dirs(contexts); 1628 return -ENOMEM; 1629 } 1630 1631 err = kobject_init_and_add(&context->kobj, 1632 &damon_sysfs_context_ktype, &contexts->kobj, 1633 "%d", i); 1634 if (err) 1635 goto out; 1636 1637 err = damon_sysfs_context_add_dirs(context); 1638 if (err) 1639 goto out; 1640 1641 contexts_arr[i] = context; 1642 contexts->nr++; 1643 } 1644 return 0; 1645 1646 out: 1647 damon_sysfs_contexts_rm_dirs(contexts); 1648 kobject_put(&context->kobj); 1649 return err; 1650 } 1651 1652 static ssize_t nr_contexts_show(struct kobject *kobj, 1653 struct kobj_attribute *attr, char *buf) 1654 { 1655 struct damon_sysfs_contexts *contexts = container_of(kobj, 1656 struct damon_sysfs_contexts, kobj); 1657 1658 return sysfs_emit(buf, "%d\n", contexts->nr); 1659 } 1660 1661 static ssize_t nr_contexts_store(struct kobject *kobj, 1662 struct kobj_attribute *attr, const char *buf, size_t count) 1663 { 1664 struct damon_sysfs_contexts *contexts; 1665 int nr, err; 1666 1667 err = kstrtoint(buf, 0, &nr); 1668 if (err) 1669 return err; 1670 /* TODO: support multiple contexts per kdamond */ 1671 if (nr < 0 || 1 < nr) 1672 return -EINVAL; 1673 1674 contexts = container_of(kobj, struct damon_sysfs_contexts, kobj); 1675 if (!mutex_trylock(&damon_sysfs_lock)) 1676 return -EBUSY; 1677 err = damon_sysfs_contexts_add_dirs(contexts, nr); 1678 mutex_unlock(&damon_sysfs_lock); 1679 if (err) 1680 return err; 1681 1682 return count; 1683 } 1684 1685 static void damon_sysfs_contexts_release(struct kobject *kobj) 1686 { 1687 kfree(container_of(kobj, struct damon_sysfs_contexts, kobj)); 1688 } 1689 1690 static struct kobj_attribute damon_sysfs_contexts_nr_attr 1691 = __ATTR_RW_MODE(nr_contexts, 0600); 1692 1693 static struct attribute *damon_sysfs_contexts_attrs[] = { 1694 &damon_sysfs_contexts_nr_attr.attr, 1695 NULL, 1696 }; 1697 ATTRIBUTE_GROUPS(damon_sysfs_contexts); 1698 1699 static const struct kobj_type damon_sysfs_contexts_ktype = { 1700 .release = damon_sysfs_contexts_release, 1701 .sysfs_ops = &kobj_sysfs_ops, 1702 .default_groups = damon_sysfs_contexts_groups, 1703 }; 1704 1705 /* 1706 * kdamond directory 1707 */ 1708 1709 struct damon_sysfs_kdamond { 1710 struct kobject kobj; 1711 struct damon_sysfs_contexts *contexts; 1712 struct damon_ctx *damon_ctx; 1713 unsigned int refresh_ms; 1714 }; 1715 1716 static struct damon_sysfs_kdamond *damon_sysfs_kdamond_alloc(void) 1717 { 1718 return kzalloc_obj(struct damon_sysfs_kdamond); 1719 } 1720 1721 static int damon_sysfs_kdamond_add_dirs(struct damon_sysfs_kdamond *kdamond) 1722 { 1723 struct damon_sysfs_contexts *contexts; 1724 int err; 1725 1726 contexts = damon_sysfs_contexts_alloc(); 1727 if (!contexts) 1728 return -ENOMEM; 1729 1730 err = kobject_init_and_add(&contexts->kobj, 1731 &damon_sysfs_contexts_ktype, &kdamond->kobj, 1732 "contexts"); 1733 if (err) { 1734 kobject_put(&contexts->kobj); 1735 return err; 1736 } 1737 kdamond->contexts = contexts; 1738 1739 return err; 1740 } 1741 1742 static void damon_sysfs_kdamond_rm_dirs(struct damon_sysfs_kdamond *kdamond) 1743 { 1744 damon_sysfs_contexts_rm_dirs(kdamond->contexts); 1745 kobject_put(&kdamond->contexts->kobj); 1746 } 1747 1748 /* 1749 * enum damon_sysfs_cmd - Commands for a specific kdamond. 1750 */ 1751 enum damon_sysfs_cmd { 1752 /* @DAMON_SYSFS_CMD_ON: Turn the kdamond on. */ 1753 DAMON_SYSFS_CMD_ON, 1754 /* @DAMON_SYSFS_CMD_OFF: Turn the kdamond off. */ 1755 DAMON_SYSFS_CMD_OFF, 1756 /* @DAMON_SYSFS_CMD_COMMIT: Update kdamond inputs. */ 1757 DAMON_SYSFS_CMD_COMMIT, 1758 /* 1759 * @DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS: Commit the quota goals 1760 * to DAMON. 1761 */ 1762 DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS, 1763 /* 1764 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS: Update scheme stats sysfs 1765 * files. 1766 */ 1767 DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS, 1768 /* 1769 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES: Update 1770 * tried_regions/total_bytes sysfs files for each scheme. 1771 */ 1772 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES, 1773 /* 1774 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS: Update schemes tried 1775 * regions 1776 */ 1777 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS, 1778 /* 1779 * @DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS: Clear schemes tried 1780 * regions 1781 */ 1782 DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS, 1783 /* 1784 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS: Update the 1785 * effective size quota of the scheme in bytes. 1786 */ 1787 DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS, 1788 /* 1789 * @DAMON_SYSFS_CMD_UPDATE_TUNED_INTERVALS: Update the tuned monitoring 1790 * intervals. 1791 */ 1792 DAMON_SYSFS_CMD_UPDATE_TUNED_INTERVALS, 1793 /* 1794 * @NR_DAMON_SYSFS_CMDS: Total number of DAMON sysfs commands. 1795 */ 1796 NR_DAMON_SYSFS_CMDS, 1797 }; 1798 1799 /* Should match with enum damon_sysfs_cmd */ 1800 static const char * const damon_sysfs_cmd_strs[] = { 1801 "on", 1802 "off", 1803 "commit", 1804 "commit_schemes_quota_goals", 1805 "update_schemes_stats", 1806 "update_schemes_tried_bytes", 1807 "update_schemes_tried_regions", 1808 "clear_schemes_tried_regions", 1809 "update_schemes_effective_quotas", 1810 "update_tuned_intervals", 1811 }; 1812 1813 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr, 1814 char *buf) 1815 { 1816 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1817 struct damon_sysfs_kdamond, kobj); 1818 struct damon_ctx *ctx; 1819 bool running = false; 1820 1821 if (!mutex_trylock(&damon_sysfs_lock)) 1822 return -EBUSY; 1823 1824 ctx = kdamond->damon_ctx; 1825 if (ctx) 1826 running = damon_is_running(ctx); 1827 1828 mutex_unlock(&damon_sysfs_lock); 1829 1830 return sysfs_emit(buf, "%s\n", running ? 1831 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_ON] : 1832 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_OFF]); 1833 } 1834 1835 static int damon_sysfs_set_attrs(struct damon_ctx *ctx, 1836 struct damon_sysfs_attrs *sys_attrs) 1837 { 1838 struct damon_sysfs_intervals *sys_intervals = sys_attrs->intervals; 1839 struct damon_sysfs_intervals_goal *sys_goal = 1840 sys_intervals->intervals_goal; 1841 struct damon_sysfs_ul_range *sys_nr_regions = 1842 sys_attrs->nr_regions_range; 1843 struct damon_attrs attrs = { 1844 .sample_interval = sys_intervals->sample_us, 1845 .aggr_interval = sys_intervals->aggr_us, 1846 .intervals_goal = { 1847 .access_bp = sys_goal->access_bp, 1848 .aggrs = sys_goal->aggrs, 1849 .min_sample_us = sys_goal->min_sample_us, 1850 .max_sample_us = sys_goal->max_sample_us}, 1851 .ops_update_interval = sys_intervals->update_us, 1852 .min_nr_regions = sys_nr_regions->min, 1853 .max_nr_regions = sys_nr_regions->max, 1854 }; 1855 return damon_set_attrs(ctx, &attrs); 1856 } 1857 1858 static int damon_sysfs_set_probes(struct damon_ctx *ctx, 1859 struct damon_sysfs_probes *sys_probes) 1860 { 1861 int i; 1862 1863 for (i = 0; i < sys_probes->nr; i++) { 1864 struct damon_sysfs_filters *sys_filters = 1865 sys_probes->probes_arr[i]->filters; 1866 struct damon_probe *c; 1867 int j; 1868 1869 if (!sys_filters) 1870 continue; 1871 c = damon_new_probe(); 1872 if (!c) 1873 return -ENOMEM; 1874 damon_add_probe(ctx, c); 1875 1876 for (j = 0; j < sys_filters->nr; j++) { 1877 struct damon_sysfs_filter *sys_filter = 1878 sys_filters->filters_arr[j]; 1879 struct damon_filter *filter; 1880 1881 filter = damon_new_filter(sys_filter->type, 1882 sys_filter->matching, 1883 sys_filter->allow); 1884 if (!filter) 1885 return -ENOMEM; 1886 damon_add_filter(c, filter); 1887 } 1888 } 1889 return 0; 1890 } 1891 1892 static int damon_sysfs_set_regions(struct damon_target *t, 1893 struct damon_sysfs_regions *sysfs_regions, 1894 unsigned long min_region_sz) 1895 { 1896 struct damon_addr_range *ranges = kmalloc_objs(*ranges, 1897 sysfs_regions->nr, 1898 GFP_KERNEL | __GFP_NOWARN); 1899 int i, err = -EINVAL; 1900 1901 if (!ranges) 1902 return -ENOMEM; 1903 for (i = 0; i < sysfs_regions->nr; i++) { 1904 struct damon_sysfs_region *sys_region = 1905 sysfs_regions->regions_arr[i]; 1906 1907 if (sys_region->ar.start > sys_region->ar.end) 1908 goto out; 1909 1910 ranges[i].start = sys_region->ar.start; 1911 ranges[i].end = sys_region->ar.end; 1912 if (i == 0) 1913 continue; 1914 if (ranges[i - 1].end > ranges[i].start) 1915 goto out; 1916 } 1917 err = damon_set_regions(t, ranges, sysfs_regions->nr, min_region_sz); 1918 out: 1919 kfree(ranges); 1920 return err; 1921 1922 } 1923 1924 static int damon_sysfs_add_target(struct damon_sysfs_target *sys_target, 1925 struct damon_ctx *ctx) 1926 { 1927 struct damon_target *t = damon_new_target(); 1928 1929 if (!t) 1930 return -ENOMEM; 1931 damon_add_target(ctx, t); 1932 if (damon_target_has_pid(ctx)) { 1933 t->pid = find_get_pid(sys_target->pid); 1934 if (!t->pid) 1935 /* caller will destroy targets */ 1936 return -EINVAL; 1937 } 1938 t->obsolete = sys_target->obsolete; 1939 return damon_sysfs_set_regions(t, sys_target->regions, 1940 ctx->min_region_sz); 1941 } 1942 1943 static int damon_sysfs_add_targets(struct damon_ctx *ctx, 1944 struct damon_sysfs_targets *sysfs_targets) 1945 { 1946 int i, err; 1947 1948 /* Multiple physical address space monitoring targets makes no sense */ 1949 if (ctx->ops.id == DAMON_OPS_PADDR && sysfs_targets->nr > 1) 1950 return -EINVAL; 1951 1952 for (i = 0; i < sysfs_targets->nr; i++) { 1953 struct damon_sysfs_target *st = sysfs_targets->targets_arr[i]; 1954 1955 err = damon_sysfs_add_target(st, ctx); 1956 if (err) 1957 return err; 1958 } 1959 return 0; 1960 } 1961 1962 /* 1963 * damon_sysfs_upd_schemes_stats() - Update schemes stats sysfs files. 1964 * @data: The kobject wrapper that associated to the kdamond thread. 1965 * 1966 * This function reads the schemes stats of specific kdamond and update the 1967 * related values for sysfs files. This function should be called from DAMON 1968 * worker thread,to safely access the DAMON contexts-internal data. Caller 1969 * should also ensure holding ``damon_syfs_lock``, and ->damon_ctx of @data is 1970 * not NULL but a valid pointer, to safely access DAMON sysfs variables. 1971 */ 1972 static int damon_sysfs_upd_schemes_stats(void *data) 1973 { 1974 struct damon_sysfs_kdamond *kdamond = data; 1975 struct damon_ctx *ctx = kdamond->damon_ctx; 1976 1977 damon_sysfs_schemes_update_stats( 1978 kdamond->contexts->contexts_arr[0]->schemes, ctx); 1979 return 0; 1980 } 1981 1982 static inline bool damon_sysfs_kdamond_running( 1983 struct damon_sysfs_kdamond *kdamond) 1984 { 1985 return kdamond->damon_ctx && 1986 damon_is_running(kdamond->damon_ctx); 1987 } 1988 1989 static int damon_sysfs_apply_inputs(struct damon_ctx *ctx, 1990 struct damon_sysfs_context *sys_ctx) 1991 { 1992 int err; 1993 1994 err = damon_select_ops(ctx, sys_ctx->ops_id); 1995 if (err) 1996 return err; 1997 ctx->addr_unit = sys_ctx->addr_unit; 1998 /* addr_unit is respected by only DAMON_OPS_PADDR */ 1999 if (sys_ctx->ops_id == DAMON_OPS_PADDR) 2000 ctx->min_region_sz = max( 2001 DAMON_MIN_REGION_SZ / sys_ctx->addr_unit, 1); 2002 ctx->pause = sys_ctx->pause; 2003 err = damon_sysfs_set_attrs(ctx, sys_ctx->attrs); 2004 if (err) 2005 return err; 2006 err = damon_sysfs_set_probes(ctx, sys_ctx->attrs->probes); 2007 if (err) 2008 return err; 2009 err = damon_sysfs_add_targets(ctx, sys_ctx->targets); 2010 if (err) 2011 return err; 2012 return damon_sysfs_add_schemes(ctx, sys_ctx->schemes); 2013 } 2014 2015 static struct damon_ctx *damon_sysfs_build_ctx( 2016 struct damon_sysfs_context *sys_ctx); 2017 2018 /* 2019 * Return a new damon_ctx for testing new parameters to commit. 2020 */ 2021 static struct damon_ctx *damon_sysfs_new_test_ctx( 2022 struct damon_ctx *running_ctx) 2023 { 2024 struct damon_ctx *test_ctx; 2025 int err; 2026 2027 test_ctx = damon_new_ctx(); 2028 if (!test_ctx) 2029 return NULL; 2030 err = damon_commit_ctx(test_ctx, running_ctx); 2031 if (err) { 2032 damon_destroy_ctx(test_ctx); 2033 return NULL; 2034 } 2035 return test_ctx; 2036 } 2037 2038 /* 2039 * damon_sysfs_commit_input() - Commit user inputs to a running kdamond. 2040 * @kdamond: The kobject wrapper for the associated kdamond. 2041 * 2042 * Returns error if the sysfs input is wrong. 2043 */ 2044 static int damon_sysfs_commit_input(void *data) 2045 { 2046 struct damon_sysfs_kdamond *kdamond = data; 2047 struct damon_ctx *param_ctx, *test_ctx; 2048 int err; 2049 2050 if (!damon_sysfs_kdamond_running(kdamond)) 2051 return -EINVAL; 2052 /* TODO: Support multiple contexts per kdamond */ 2053 if (kdamond->contexts->nr != 1) 2054 return -EINVAL; 2055 2056 param_ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]); 2057 if (IS_ERR(param_ctx)) 2058 return PTR_ERR(param_ctx); 2059 test_ctx = damon_sysfs_new_test_ctx(kdamond->damon_ctx); 2060 if (!test_ctx) { 2061 damon_destroy_ctx(param_ctx); 2062 return -ENOMEM; 2063 } 2064 err = damon_commit_ctx(test_ctx, param_ctx); 2065 if (err) 2066 goto out; 2067 err = damon_commit_ctx(kdamond->damon_ctx, param_ctx); 2068 out: 2069 damon_destroy_ctx(test_ctx); 2070 damon_destroy_ctx(param_ctx); 2071 return err; 2072 } 2073 2074 static int damon_sysfs_commit_schemes_quota_goals(void *data) 2075 { 2076 struct damon_sysfs_kdamond *sysfs_kdamond = data; 2077 struct damon_ctx *ctx; 2078 struct damon_sysfs_context *sysfs_ctx; 2079 2080 if (!damon_sysfs_kdamond_running(sysfs_kdamond)) 2081 return -EINVAL; 2082 /* TODO: Support multiple contexts per kdamond */ 2083 if (sysfs_kdamond->contexts->nr != 1) 2084 return -EINVAL; 2085 2086 ctx = sysfs_kdamond->damon_ctx; 2087 sysfs_ctx = sysfs_kdamond->contexts->contexts_arr[0]; 2088 return damos_sysfs_set_quota_scores(sysfs_ctx->schemes, ctx); 2089 } 2090 2091 /* 2092 * damon_sysfs_upd_schemes_effective_quotas() - Update schemes effective quotas 2093 * sysfs files. 2094 * @data: The kobject wrapper that associated to the kdamond thread. 2095 * 2096 * This function reads the schemes' effective quotas of specific kdamond and 2097 * update the related values for sysfs files. This function should be called 2098 * from DAMON callbacks while holding ``damon_syfs_lock``, to safely access the 2099 * DAMON contexts-internal data and DAMON sysfs variables. 2100 */ 2101 static int damon_sysfs_upd_schemes_effective_quotas(void *data) 2102 { 2103 struct damon_sysfs_kdamond *kdamond = data; 2104 struct damon_ctx *ctx = kdamond->damon_ctx; 2105 2106 damos_sysfs_update_effective_quotas( 2107 kdamond->contexts->contexts_arr[0]->schemes, ctx); 2108 return 0; 2109 } 2110 2111 static int damon_sysfs_upd_tuned_intervals(void *data) 2112 { 2113 struct damon_sysfs_kdamond *kdamond = data; 2114 struct damon_ctx *ctx = kdamond->damon_ctx; 2115 2116 kdamond->contexts->contexts_arr[0]->attrs->intervals->sample_us = 2117 ctx->attrs.sample_interval; 2118 kdamond->contexts->contexts_arr[0]->attrs->intervals->aggr_us = 2119 ctx->attrs.aggr_interval; 2120 return 0; 2121 } 2122 2123 static struct damon_ctx *damon_sysfs_build_ctx( 2124 struct damon_sysfs_context *sys_ctx) 2125 { 2126 struct damon_ctx *ctx = damon_new_ctx(); 2127 int err; 2128 2129 if (!ctx) 2130 return ERR_PTR(-ENOMEM); 2131 2132 err = damon_sysfs_apply_inputs(ctx, sys_ctx); 2133 if (err) { 2134 damon_destroy_ctx(ctx); 2135 return ERR_PTR(err); 2136 } 2137 2138 return ctx; 2139 } 2140 2141 static unsigned long damon_sysfs_next_update_jiffies; 2142 2143 static int damon_sysfs_repeat_call_fn(void *data) 2144 { 2145 struct damon_sysfs_kdamond *sysfs_kdamond = data; 2146 2147 if (!sysfs_kdamond->refresh_ms) 2148 return 0; 2149 if (time_before(jiffies, damon_sysfs_next_update_jiffies)) 2150 return 0; 2151 damon_sysfs_next_update_jiffies = jiffies + 2152 msecs_to_jiffies(sysfs_kdamond->refresh_ms); 2153 2154 if (!mutex_trylock(&damon_sysfs_lock)) 2155 return 0; 2156 if (sysfs_kdamond->contexts->nr != 1) 2157 goto out; 2158 damon_sysfs_upd_tuned_intervals(sysfs_kdamond); 2159 damon_sysfs_upd_schemes_stats(sysfs_kdamond); 2160 damon_sysfs_upd_schemes_effective_quotas(sysfs_kdamond); 2161 out: 2162 mutex_unlock(&damon_sysfs_lock); 2163 return 0; 2164 } 2165 2166 static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond) 2167 { 2168 struct damon_ctx *ctx; 2169 struct damon_call_control *repeat_call_control; 2170 int err; 2171 2172 if (damon_sysfs_kdamond_running(kdamond)) 2173 return -EBUSY; 2174 /* TODO: support multiple contexts per kdamond */ 2175 if (kdamond->contexts->nr != 1) 2176 return -EINVAL; 2177 2178 if (kdamond->damon_ctx) 2179 damon_destroy_ctx(kdamond->damon_ctx); 2180 kdamond->damon_ctx = NULL; 2181 2182 repeat_call_control = kmalloc_obj(*repeat_call_control); 2183 if (!repeat_call_control) 2184 return -ENOMEM; 2185 2186 ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]); 2187 if (IS_ERR(ctx)) { 2188 kfree(repeat_call_control); 2189 return PTR_ERR(ctx); 2190 } 2191 err = damon_start(&ctx, 1, false); 2192 if (err) { 2193 kfree(repeat_call_control); 2194 damon_destroy_ctx(ctx); 2195 return err; 2196 } 2197 kdamond->damon_ctx = ctx; 2198 2199 damon_sysfs_next_update_jiffies = 2200 jiffies + msecs_to_jiffies(kdamond->refresh_ms); 2201 2202 repeat_call_control->fn = damon_sysfs_repeat_call_fn; 2203 repeat_call_control->data = kdamond; 2204 repeat_call_control->repeat = true; 2205 repeat_call_control->dealloc_on_cancel = true; 2206 if (damon_call(ctx, repeat_call_control)) 2207 kfree(repeat_call_control); 2208 return err; 2209 } 2210 2211 static int damon_sysfs_turn_damon_off(struct damon_sysfs_kdamond *kdamond) 2212 { 2213 if (!kdamond->damon_ctx) 2214 return -EINVAL; 2215 return damon_stop(&kdamond->damon_ctx, 1); 2216 /* 2217 * To allow users show final monitoring results of already turned-off 2218 * DAMON, we free kdamond->damon_ctx in next 2219 * damon_sysfs_turn_damon_on(), or kdamonds_nr_store() 2220 */ 2221 } 2222 2223 static int damon_sysfs_damon_call(int (*fn)(void *data), 2224 struct damon_sysfs_kdamond *kdamond) 2225 { 2226 struct damon_call_control call_control = {}; 2227 int err; 2228 2229 if (!kdamond->damon_ctx) 2230 return -EINVAL; 2231 call_control.fn = fn; 2232 call_control.data = kdamond; 2233 err = damon_call(kdamond->damon_ctx, &call_control); 2234 return err ? err : call_control.return_code; 2235 } 2236 2237 struct damon_sysfs_schemes_walk_data { 2238 struct damon_sysfs_kdamond *sysfs_kdamond; 2239 bool total_bytes_only; 2240 }; 2241 2242 /* populate the region directory */ 2243 static void damon_sysfs_schemes_tried_regions_upd_one(void *data, struct damon_ctx *ctx, 2244 struct damon_target *t, struct damon_region *r, 2245 struct damos *s, unsigned long sz_filter_passed) 2246 { 2247 struct damon_sysfs_schemes_walk_data *walk_data = data; 2248 struct damon_sysfs_kdamond *sysfs_kdamond = walk_data->sysfs_kdamond; 2249 2250 damos_sysfs_populate_region_dir( 2251 sysfs_kdamond->contexts->contexts_arr[0]->schemes, 2252 ctx, t, r, s, walk_data->total_bytes_only, 2253 sz_filter_passed); 2254 } 2255 2256 static int damon_sysfs_update_schemes_tried_regions( 2257 struct damon_sysfs_kdamond *sysfs_kdamond, bool total_bytes_only) 2258 { 2259 struct damon_sysfs_schemes_walk_data walk_data = { 2260 .sysfs_kdamond = sysfs_kdamond, 2261 .total_bytes_only = total_bytes_only, 2262 }; 2263 struct damos_walk_control control = { 2264 .walk_fn = damon_sysfs_schemes_tried_regions_upd_one, 2265 .data = &walk_data, 2266 }; 2267 struct damon_ctx *ctx = sysfs_kdamond->damon_ctx; 2268 2269 if (!ctx) 2270 return -EINVAL; 2271 2272 damon_sysfs_schemes_clear_regions( 2273 sysfs_kdamond->contexts->contexts_arr[0]->schemes); 2274 return damos_walk(ctx, &control); 2275 } 2276 2277 /* 2278 * damon_sysfs_handle_cmd() - Handle a command for a specific kdamond. 2279 * @cmd: The command to handle. 2280 * @kdamond: The kobject wrapper for the associated kdamond. 2281 * 2282 * This function handles a DAMON sysfs command for a kdamond. 2283 * 2284 * Return: 0 on success, negative error code otherwise. 2285 */ 2286 static int damon_sysfs_handle_cmd(enum damon_sysfs_cmd cmd, 2287 struct damon_sysfs_kdamond *kdamond) 2288 { 2289 if (cmd != DAMON_SYSFS_CMD_OFF && kdamond->contexts->nr != 1) 2290 return -EINVAL; 2291 2292 switch (cmd) { 2293 case DAMON_SYSFS_CMD_ON: 2294 return damon_sysfs_turn_damon_on(kdamond); 2295 case DAMON_SYSFS_CMD_OFF: 2296 return damon_sysfs_turn_damon_off(kdamond); 2297 case DAMON_SYSFS_CMD_COMMIT: 2298 return damon_sysfs_damon_call( 2299 damon_sysfs_commit_input, kdamond); 2300 case DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS: 2301 return damon_sysfs_damon_call( 2302 damon_sysfs_commit_schemes_quota_goals, 2303 kdamond); 2304 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS: 2305 return damon_sysfs_damon_call( 2306 damon_sysfs_upd_schemes_stats, kdamond); 2307 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES: 2308 return damon_sysfs_update_schemes_tried_regions(kdamond, true); 2309 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS: 2310 return damon_sysfs_update_schemes_tried_regions(kdamond, false); 2311 case DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS: 2312 return damon_sysfs_schemes_clear_regions( 2313 kdamond->contexts->contexts_arr[0]->schemes); 2314 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS: 2315 return damon_sysfs_damon_call( 2316 damon_sysfs_upd_schemes_effective_quotas, 2317 kdamond); 2318 case DAMON_SYSFS_CMD_UPDATE_TUNED_INTERVALS: 2319 return damon_sysfs_damon_call( 2320 damon_sysfs_upd_tuned_intervals, kdamond); 2321 default: 2322 return -EINVAL; 2323 } 2324 } 2325 2326 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr, 2327 const char *buf, size_t count) 2328 { 2329 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 2330 struct damon_sysfs_kdamond, kobj); 2331 enum damon_sysfs_cmd cmd; 2332 ssize_t ret = -EINVAL; 2333 2334 if (!mutex_trylock(&damon_sysfs_lock)) 2335 return -EBUSY; 2336 for (cmd = 0; cmd < NR_DAMON_SYSFS_CMDS; cmd++) { 2337 if (sysfs_streq(buf, damon_sysfs_cmd_strs[cmd])) { 2338 ret = damon_sysfs_handle_cmd(cmd, kdamond); 2339 break; 2340 } 2341 } 2342 mutex_unlock(&damon_sysfs_lock); 2343 if (!ret) 2344 ret = count; 2345 return ret; 2346 } 2347 2348 static ssize_t pid_show(struct kobject *kobj, 2349 struct kobj_attribute *attr, char *buf) 2350 { 2351 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 2352 struct damon_sysfs_kdamond, kobj); 2353 struct damon_ctx *ctx; 2354 int pid = -1; 2355 2356 if (!mutex_trylock(&damon_sysfs_lock)) 2357 return -EBUSY; 2358 ctx = kdamond->damon_ctx; 2359 if (!ctx) 2360 goto out; 2361 2362 pid = damon_kdamond_pid(ctx); 2363 if (pid < 0) 2364 pid = -1; 2365 out: 2366 mutex_unlock(&damon_sysfs_lock); 2367 return sysfs_emit(buf, "%d\n", pid); 2368 } 2369 2370 static ssize_t refresh_ms_show(struct kobject *kobj, 2371 struct kobj_attribute *attr, char *buf) 2372 { 2373 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 2374 struct damon_sysfs_kdamond, kobj); 2375 2376 return sysfs_emit(buf, "%u\n", kdamond->refresh_ms); 2377 } 2378 2379 static ssize_t refresh_ms_store(struct kobject *kobj, 2380 struct kobj_attribute *attr, const char *buf, size_t count) 2381 { 2382 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 2383 struct damon_sysfs_kdamond, kobj); 2384 unsigned int nr; 2385 int err = kstrtouint(buf, 0, &nr); 2386 2387 if (err) 2388 return err; 2389 2390 kdamond->refresh_ms = nr; 2391 return count; 2392 } 2393 2394 static void damon_sysfs_kdamond_release(struct kobject *kobj) 2395 { 2396 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 2397 struct damon_sysfs_kdamond, kobj); 2398 2399 if (kdamond->damon_ctx) 2400 damon_destroy_ctx(kdamond->damon_ctx); 2401 kfree(kdamond); 2402 } 2403 2404 static struct kobj_attribute damon_sysfs_kdamond_state_attr = 2405 __ATTR_RW_MODE(state, 0600); 2406 2407 static struct kobj_attribute damon_sysfs_kdamond_pid_attr = 2408 __ATTR_RO_MODE(pid, 0400); 2409 2410 static struct kobj_attribute damon_sysfs_kdamond_refresh_ms_attr = 2411 __ATTR_RW_MODE(refresh_ms, 0600); 2412 2413 static struct attribute *damon_sysfs_kdamond_attrs[] = { 2414 &damon_sysfs_kdamond_state_attr.attr, 2415 &damon_sysfs_kdamond_pid_attr.attr, 2416 &damon_sysfs_kdamond_refresh_ms_attr.attr, 2417 NULL, 2418 }; 2419 ATTRIBUTE_GROUPS(damon_sysfs_kdamond); 2420 2421 static const struct kobj_type damon_sysfs_kdamond_ktype = { 2422 .release = damon_sysfs_kdamond_release, 2423 .sysfs_ops = &kobj_sysfs_ops, 2424 .default_groups = damon_sysfs_kdamond_groups, 2425 }; 2426 2427 /* 2428 * kdamonds directory 2429 */ 2430 2431 struct damon_sysfs_kdamonds { 2432 struct kobject kobj; 2433 struct damon_sysfs_kdamond **kdamonds_arr; 2434 int nr; 2435 }; 2436 2437 static struct damon_sysfs_kdamonds *damon_sysfs_kdamonds_alloc(void) 2438 { 2439 return kzalloc_obj(struct damon_sysfs_kdamonds); 2440 } 2441 2442 static void damon_sysfs_kdamonds_rm_dirs(struct damon_sysfs_kdamonds *kdamonds) 2443 { 2444 struct damon_sysfs_kdamond **kdamonds_arr = kdamonds->kdamonds_arr; 2445 int i; 2446 2447 for (i = 0; i < kdamonds->nr; i++) { 2448 damon_sysfs_kdamond_rm_dirs(kdamonds_arr[i]); 2449 kobject_put(&kdamonds_arr[i]->kobj); 2450 } 2451 kdamonds->nr = 0; 2452 kfree(kdamonds_arr); 2453 kdamonds->kdamonds_arr = NULL; 2454 } 2455 2456 static bool damon_sysfs_kdamonds_busy(struct damon_sysfs_kdamond **kdamonds, 2457 int nr_kdamonds) 2458 { 2459 int i; 2460 2461 for (i = 0; i < nr_kdamonds; i++) { 2462 if (damon_sysfs_kdamond_running(kdamonds[i])) 2463 return true; 2464 } 2465 2466 return false; 2467 } 2468 2469 static int damon_sysfs_kdamonds_add_dirs(struct damon_sysfs_kdamonds *kdamonds, 2470 int nr_kdamonds) 2471 { 2472 struct damon_sysfs_kdamond **kdamonds_arr, *kdamond; 2473 int err, i; 2474 2475 if (damon_sysfs_kdamonds_busy(kdamonds->kdamonds_arr, kdamonds->nr)) 2476 return -EBUSY; 2477 2478 damon_sysfs_kdamonds_rm_dirs(kdamonds); 2479 if (!nr_kdamonds) 2480 return 0; 2481 2482 kdamonds_arr = kmalloc_objs(*kdamonds_arr, nr_kdamonds, 2483 GFP_KERNEL | __GFP_NOWARN); 2484 if (!kdamonds_arr) 2485 return -ENOMEM; 2486 kdamonds->kdamonds_arr = kdamonds_arr; 2487 2488 for (i = 0; i < nr_kdamonds; i++) { 2489 kdamond = damon_sysfs_kdamond_alloc(); 2490 if (!kdamond) { 2491 damon_sysfs_kdamonds_rm_dirs(kdamonds); 2492 return -ENOMEM; 2493 } 2494 2495 err = kobject_init_and_add(&kdamond->kobj, 2496 &damon_sysfs_kdamond_ktype, &kdamonds->kobj, 2497 "%d", i); 2498 if (err) 2499 goto out; 2500 2501 err = damon_sysfs_kdamond_add_dirs(kdamond); 2502 if (err) 2503 goto out; 2504 2505 kdamonds_arr[i] = kdamond; 2506 kdamonds->nr++; 2507 } 2508 return 0; 2509 2510 out: 2511 damon_sysfs_kdamonds_rm_dirs(kdamonds); 2512 kobject_put(&kdamond->kobj); 2513 return err; 2514 } 2515 2516 static ssize_t nr_kdamonds_show(struct kobject *kobj, 2517 struct kobj_attribute *attr, char *buf) 2518 { 2519 struct damon_sysfs_kdamonds *kdamonds = container_of(kobj, 2520 struct damon_sysfs_kdamonds, kobj); 2521 2522 return sysfs_emit(buf, "%d\n", kdamonds->nr); 2523 } 2524 2525 static ssize_t nr_kdamonds_store(struct kobject *kobj, 2526 struct kobj_attribute *attr, const char *buf, size_t count) 2527 { 2528 struct damon_sysfs_kdamonds *kdamonds; 2529 int nr, err; 2530 2531 err = kstrtoint(buf, 0, &nr); 2532 if (err) 2533 return err; 2534 if (nr < 0) 2535 return -EINVAL; 2536 2537 kdamonds = container_of(kobj, struct damon_sysfs_kdamonds, kobj); 2538 2539 if (!mutex_trylock(&damon_sysfs_lock)) 2540 return -EBUSY; 2541 err = damon_sysfs_kdamonds_add_dirs(kdamonds, nr); 2542 mutex_unlock(&damon_sysfs_lock); 2543 if (err) 2544 return err; 2545 2546 return count; 2547 } 2548 2549 static void damon_sysfs_kdamonds_release(struct kobject *kobj) 2550 { 2551 kfree(container_of(kobj, struct damon_sysfs_kdamonds, kobj)); 2552 } 2553 2554 static struct kobj_attribute damon_sysfs_kdamonds_nr_attr = 2555 __ATTR_RW_MODE(nr_kdamonds, 0600); 2556 2557 static struct attribute *damon_sysfs_kdamonds_attrs[] = { 2558 &damon_sysfs_kdamonds_nr_attr.attr, 2559 NULL, 2560 }; 2561 ATTRIBUTE_GROUPS(damon_sysfs_kdamonds); 2562 2563 static const struct kobj_type damon_sysfs_kdamonds_ktype = { 2564 .release = damon_sysfs_kdamonds_release, 2565 .sysfs_ops = &kobj_sysfs_ops, 2566 .default_groups = damon_sysfs_kdamonds_groups, 2567 }; 2568 2569 /* 2570 * damon user interface directory 2571 */ 2572 2573 struct damon_sysfs_ui_dir { 2574 struct kobject kobj; 2575 struct damon_sysfs_kdamonds *kdamonds; 2576 }; 2577 2578 static struct damon_sysfs_ui_dir *damon_sysfs_ui_dir_alloc(void) 2579 { 2580 return kzalloc_obj(struct damon_sysfs_ui_dir); 2581 } 2582 2583 static int damon_sysfs_ui_dir_add_dirs(struct damon_sysfs_ui_dir *ui_dir) 2584 { 2585 struct damon_sysfs_kdamonds *kdamonds; 2586 int err; 2587 2588 kdamonds = damon_sysfs_kdamonds_alloc(); 2589 if (!kdamonds) 2590 return -ENOMEM; 2591 2592 err = kobject_init_and_add(&kdamonds->kobj, 2593 &damon_sysfs_kdamonds_ktype, &ui_dir->kobj, 2594 "kdamonds"); 2595 if (err) { 2596 kobject_put(&kdamonds->kobj); 2597 return err; 2598 } 2599 ui_dir->kdamonds = kdamonds; 2600 return err; 2601 } 2602 2603 static void damon_sysfs_ui_dir_release(struct kobject *kobj) 2604 { 2605 kfree(container_of(kobj, struct damon_sysfs_ui_dir, kobj)); 2606 } 2607 2608 static struct attribute *damon_sysfs_ui_dir_attrs[] = { 2609 NULL, 2610 }; 2611 ATTRIBUTE_GROUPS(damon_sysfs_ui_dir); 2612 2613 static const struct kobj_type damon_sysfs_ui_dir_ktype = { 2614 .release = damon_sysfs_ui_dir_release, 2615 .sysfs_ops = &kobj_sysfs_ops, 2616 .default_groups = damon_sysfs_ui_dir_groups, 2617 }; 2618 2619 static int __init damon_sysfs_init(void) 2620 { 2621 struct kobject *damon_sysfs_root; 2622 struct damon_sysfs_ui_dir *admin; 2623 int err; 2624 2625 damon_sysfs_root = kobject_create_and_add("damon", mm_kobj); 2626 if (!damon_sysfs_root) 2627 return -ENOMEM; 2628 2629 admin = damon_sysfs_ui_dir_alloc(); 2630 if (!admin) { 2631 kobject_put(damon_sysfs_root); 2632 return -ENOMEM; 2633 } 2634 err = kobject_init_and_add(&admin->kobj, &damon_sysfs_ui_dir_ktype, 2635 damon_sysfs_root, "admin"); 2636 if (err) 2637 goto out; 2638 err = damon_sysfs_ui_dir_add_dirs(admin); 2639 if (err) 2640 goto out; 2641 return 0; 2642 2643 out: 2644 kobject_put(&admin->kobj); 2645 kobject_put(damon_sysfs_root); 2646 return err; 2647 } 2648 subsys_initcall(damon_sysfs_init); 2649 2650 #include "tests/sysfs-kunit.h" 2651