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 * monitoring_attrs directory 752 */ 753 754 struct damon_sysfs_attrs { 755 struct kobject kobj; 756 struct damon_sysfs_intervals *intervals; 757 struct damon_sysfs_ul_range *nr_regions_range; 758 }; 759 760 static struct damon_sysfs_attrs *damon_sysfs_attrs_alloc(void) 761 { 762 struct damon_sysfs_attrs *attrs = kmalloc_obj(*attrs); 763 764 if (!attrs) 765 return NULL; 766 attrs->kobj = (struct kobject){}; 767 return attrs; 768 } 769 770 static int damon_sysfs_attrs_add_dirs(struct damon_sysfs_attrs *attrs) 771 { 772 struct damon_sysfs_intervals *intervals; 773 struct damon_sysfs_ul_range *nr_regions_range; 774 int err; 775 776 intervals = damon_sysfs_intervals_alloc(5000, 100000, 60000000); 777 if (!intervals) 778 return -ENOMEM; 779 780 err = kobject_init_and_add(&intervals->kobj, 781 &damon_sysfs_intervals_ktype, &attrs->kobj, 782 "intervals"); 783 if (err) 784 goto put_intervals_out; 785 err = damon_sysfs_intervals_add_dirs(intervals); 786 if (err) 787 goto put_intervals_out; 788 attrs->intervals = intervals; 789 790 nr_regions_range = damon_sysfs_ul_range_alloc(10, 1000); 791 if (!nr_regions_range) { 792 err = -ENOMEM; 793 goto rmdir_put_intervals_out; 794 } 795 796 err = kobject_init_and_add(&nr_regions_range->kobj, 797 &damon_sysfs_ul_range_ktype, &attrs->kobj, 798 "nr_regions"); 799 if (err) 800 goto put_nr_regions_intervals_out; 801 attrs->nr_regions_range = nr_regions_range; 802 return 0; 803 804 put_nr_regions_intervals_out: 805 kobject_put(&nr_regions_range->kobj); 806 attrs->nr_regions_range = NULL; 807 rmdir_put_intervals_out: 808 damon_sysfs_intervals_rm_dirs(intervals); 809 put_intervals_out: 810 kobject_put(&intervals->kobj); 811 attrs->intervals = NULL; 812 return err; 813 } 814 815 static void damon_sysfs_attrs_rm_dirs(struct damon_sysfs_attrs *attrs) 816 { 817 kobject_put(&attrs->nr_regions_range->kobj); 818 damon_sysfs_intervals_rm_dirs(attrs->intervals); 819 kobject_put(&attrs->intervals->kobj); 820 } 821 822 static void damon_sysfs_attrs_release(struct kobject *kobj) 823 { 824 kfree(container_of(kobj, struct damon_sysfs_attrs, kobj)); 825 } 826 827 static struct attribute *damon_sysfs_attrs_attrs[] = { 828 NULL, 829 }; 830 ATTRIBUTE_GROUPS(damon_sysfs_attrs); 831 832 static const struct kobj_type damon_sysfs_attrs_ktype = { 833 .release = damon_sysfs_attrs_release, 834 .sysfs_ops = &kobj_sysfs_ops, 835 .default_groups = damon_sysfs_attrs_groups, 836 }; 837 838 /* 839 * context directory 840 */ 841 842 struct damon_sysfs_ops_name { 843 enum damon_ops_id ops_id; 844 char *name; 845 }; 846 847 static const struct damon_sysfs_ops_name damon_sysfs_ops_names[] = { 848 { 849 .ops_id = DAMON_OPS_VADDR, 850 .name = "vaddr", 851 }, 852 { 853 .ops_id = DAMON_OPS_FVADDR, 854 .name = "fvaddr", 855 }, 856 { 857 .ops_id = DAMON_OPS_PADDR, 858 .name = "paddr", 859 }, 860 }; 861 862 struct damon_sysfs_context { 863 struct kobject kobj; 864 enum damon_ops_id ops_id; 865 unsigned long addr_unit; 866 struct damon_sysfs_attrs *attrs; 867 struct damon_sysfs_targets *targets; 868 struct damon_sysfs_schemes *schemes; 869 bool pause; 870 }; 871 872 static struct damon_sysfs_context *damon_sysfs_context_alloc( 873 enum damon_ops_id ops_id) 874 { 875 struct damon_sysfs_context *context = kmalloc_obj(*context); 876 877 if (!context) 878 return NULL; 879 context->kobj = (struct kobject){}; 880 context->ops_id = ops_id; 881 context->addr_unit = 1; 882 context->pause = false; 883 return context; 884 } 885 886 static int damon_sysfs_context_set_attrs(struct damon_sysfs_context *context) 887 { 888 struct damon_sysfs_attrs *attrs = damon_sysfs_attrs_alloc(); 889 int err; 890 891 if (!attrs) 892 return -ENOMEM; 893 err = kobject_init_and_add(&attrs->kobj, &damon_sysfs_attrs_ktype, 894 &context->kobj, "monitoring_attrs"); 895 if (err) 896 goto out; 897 err = damon_sysfs_attrs_add_dirs(attrs); 898 if (err) 899 goto out; 900 context->attrs = attrs; 901 return 0; 902 903 out: 904 kobject_put(&attrs->kobj); 905 return err; 906 } 907 908 static int damon_sysfs_context_set_targets(struct damon_sysfs_context *context) 909 { 910 struct damon_sysfs_targets *targets = damon_sysfs_targets_alloc(); 911 int err; 912 913 if (!targets) 914 return -ENOMEM; 915 err = kobject_init_and_add(&targets->kobj, &damon_sysfs_targets_ktype, 916 &context->kobj, "targets"); 917 if (err) { 918 kobject_put(&targets->kobj); 919 return err; 920 } 921 context->targets = targets; 922 return 0; 923 } 924 925 static int damon_sysfs_context_set_schemes(struct damon_sysfs_context *context) 926 { 927 struct damon_sysfs_schemes *schemes = damon_sysfs_schemes_alloc(); 928 int err; 929 930 if (!schemes) 931 return -ENOMEM; 932 err = kobject_init_and_add(&schemes->kobj, &damon_sysfs_schemes_ktype, 933 &context->kobj, "schemes"); 934 if (err) { 935 kobject_put(&schemes->kobj); 936 return err; 937 } 938 context->schemes = schemes; 939 return 0; 940 } 941 942 static int damon_sysfs_context_add_dirs(struct damon_sysfs_context *context) 943 { 944 int err; 945 946 err = damon_sysfs_context_set_attrs(context); 947 if (err) 948 return err; 949 950 err = damon_sysfs_context_set_targets(context); 951 if (err) 952 goto rmdir_put_attrs_out; 953 954 err = damon_sysfs_context_set_schemes(context); 955 if (err) 956 goto put_targets_attrs_out; 957 return 0; 958 959 put_targets_attrs_out: 960 kobject_put(&context->targets->kobj); 961 context->targets = NULL; 962 rmdir_put_attrs_out: 963 damon_sysfs_attrs_rm_dirs(context->attrs); 964 kobject_put(&context->attrs->kobj); 965 context->attrs = NULL; 966 return err; 967 } 968 969 static void damon_sysfs_context_rm_dirs(struct damon_sysfs_context *context) 970 { 971 damon_sysfs_attrs_rm_dirs(context->attrs); 972 kobject_put(&context->attrs->kobj); 973 damon_sysfs_targets_rm_dirs(context->targets); 974 kobject_put(&context->targets->kobj); 975 damon_sysfs_schemes_rm_dirs(context->schemes); 976 kobject_put(&context->schemes->kobj); 977 } 978 979 static ssize_t avail_operations_show(struct kobject *kobj, 980 struct kobj_attribute *attr, char *buf) 981 { 982 int len = 0; 983 int i; 984 985 for (i = 0; i < ARRAY_SIZE(damon_sysfs_ops_names); i++) { 986 const struct damon_sysfs_ops_name *ops_name; 987 988 ops_name = &damon_sysfs_ops_names[i]; 989 if (!damon_is_registered_ops(ops_name->ops_id)) 990 continue; 991 len += sysfs_emit_at(buf, len, "%s\n", ops_name->name); 992 } 993 return len; 994 } 995 996 static ssize_t operations_show(struct kobject *kobj, 997 struct kobj_attribute *attr, char *buf) 998 { 999 struct damon_sysfs_context *context = container_of(kobj, 1000 struct damon_sysfs_context, kobj); 1001 int i; 1002 1003 for (i = 0; i < ARRAY_SIZE(damon_sysfs_ops_names); i++) { 1004 const struct damon_sysfs_ops_name *ops_name; 1005 1006 ops_name = &damon_sysfs_ops_names[i]; 1007 if (ops_name->ops_id == context->ops_id) 1008 return sysfs_emit(buf, "%s\n", ops_name->name); 1009 } 1010 return -EINVAL; 1011 } 1012 1013 static ssize_t operations_store(struct kobject *kobj, 1014 struct kobj_attribute *attr, const char *buf, size_t count) 1015 { 1016 struct damon_sysfs_context *context = container_of(kobj, 1017 struct damon_sysfs_context, kobj); 1018 int i; 1019 1020 for (i = 0; i < ARRAY_SIZE(damon_sysfs_ops_names); i++) { 1021 const struct damon_sysfs_ops_name *ops_name; 1022 1023 ops_name = &damon_sysfs_ops_names[i]; 1024 if (sysfs_streq(buf, ops_name->name)) { 1025 context->ops_id = ops_name->ops_id; 1026 return count; 1027 } 1028 } 1029 return -EINVAL; 1030 } 1031 1032 static ssize_t addr_unit_show(struct kobject *kobj, 1033 struct kobj_attribute *attr, char *buf) 1034 { 1035 struct damon_sysfs_context *context = container_of(kobj, 1036 struct damon_sysfs_context, kobj); 1037 1038 return sysfs_emit(buf, "%lu\n", context->addr_unit); 1039 } 1040 1041 static ssize_t addr_unit_store(struct kobject *kobj, 1042 struct kobj_attribute *attr, const char *buf, size_t count) 1043 { 1044 struct damon_sysfs_context *context = container_of(kobj, 1045 struct damon_sysfs_context, kobj); 1046 unsigned long input_addr_unit; 1047 int err = kstrtoul(buf, 0, &input_addr_unit); 1048 1049 if (err) 1050 return err; 1051 if (!input_addr_unit) 1052 return -EINVAL; 1053 1054 context->addr_unit = input_addr_unit; 1055 return count; 1056 } 1057 1058 static ssize_t pause_show(struct kobject *kobj, struct kobj_attribute *attr, 1059 char *buf) 1060 { 1061 struct damon_sysfs_context *context = container_of(kobj, 1062 struct damon_sysfs_context, kobj); 1063 1064 return sysfs_emit(buf, "%c\n", context->pause ? 'Y' : 'N'); 1065 } 1066 1067 static ssize_t pause_store(struct kobject *kobj, struct kobj_attribute *attr, 1068 const char *buf, size_t count) 1069 { 1070 struct damon_sysfs_context *context = container_of(kobj, 1071 struct damon_sysfs_context, kobj); 1072 bool pause; 1073 int err = kstrtobool(buf, &pause); 1074 1075 if (err) 1076 return err; 1077 context->pause = pause; 1078 return count; 1079 } 1080 1081 1082 static void damon_sysfs_context_release(struct kobject *kobj) 1083 { 1084 kfree(container_of(kobj, struct damon_sysfs_context, kobj)); 1085 } 1086 1087 static struct kobj_attribute damon_sysfs_context_avail_operations_attr = 1088 __ATTR_RO_MODE(avail_operations, 0400); 1089 1090 static struct kobj_attribute damon_sysfs_context_operations_attr = 1091 __ATTR_RW_MODE(operations, 0600); 1092 1093 static struct kobj_attribute damon_sysfs_context_addr_unit_attr = 1094 __ATTR_RW_MODE(addr_unit, 0600); 1095 1096 static struct kobj_attribute damon_sysfs_context_pause_attr = 1097 __ATTR_RW_MODE(pause, 0600); 1098 1099 static struct attribute *damon_sysfs_context_attrs[] = { 1100 &damon_sysfs_context_avail_operations_attr.attr, 1101 &damon_sysfs_context_operations_attr.attr, 1102 &damon_sysfs_context_addr_unit_attr.attr, 1103 &damon_sysfs_context_pause_attr.attr, 1104 NULL, 1105 }; 1106 ATTRIBUTE_GROUPS(damon_sysfs_context); 1107 1108 static const struct kobj_type damon_sysfs_context_ktype = { 1109 .release = damon_sysfs_context_release, 1110 .sysfs_ops = &kobj_sysfs_ops, 1111 .default_groups = damon_sysfs_context_groups, 1112 }; 1113 1114 /* 1115 * contexts directory 1116 */ 1117 1118 struct damon_sysfs_contexts { 1119 struct kobject kobj; 1120 struct damon_sysfs_context **contexts_arr; 1121 int nr; 1122 }; 1123 1124 static struct damon_sysfs_contexts *damon_sysfs_contexts_alloc(void) 1125 { 1126 return kzalloc_obj(struct damon_sysfs_contexts); 1127 } 1128 1129 static void damon_sysfs_contexts_rm_dirs(struct damon_sysfs_contexts *contexts) 1130 { 1131 struct damon_sysfs_context **contexts_arr = contexts->contexts_arr; 1132 int i; 1133 1134 for (i = 0; i < contexts->nr; i++) { 1135 damon_sysfs_context_rm_dirs(contexts_arr[i]); 1136 kobject_put(&contexts_arr[i]->kobj); 1137 } 1138 contexts->nr = 0; 1139 kfree(contexts_arr); 1140 contexts->contexts_arr = NULL; 1141 } 1142 1143 static int damon_sysfs_contexts_add_dirs(struct damon_sysfs_contexts *contexts, 1144 int nr_contexts) 1145 { 1146 struct damon_sysfs_context **contexts_arr, *context; 1147 int err, i; 1148 1149 damon_sysfs_contexts_rm_dirs(contexts); 1150 if (!nr_contexts) 1151 return 0; 1152 1153 contexts_arr = kmalloc_objs(*contexts_arr, nr_contexts, 1154 GFP_KERNEL | __GFP_NOWARN); 1155 if (!contexts_arr) 1156 return -ENOMEM; 1157 contexts->contexts_arr = contexts_arr; 1158 1159 for (i = 0; i < nr_contexts; i++) { 1160 context = damon_sysfs_context_alloc(DAMON_OPS_VADDR); 1161 if (!context) { 1162 damon_sysfs_contexts_rm_dirs(contexts); 1163 return -ENOMEM; 1164 } 1165 1166 err = kobject_init_and_add(&context->kobj, 1167 &damon_sysfs_context_ktype, &contexts->kobj, 1168 "%d", i); 1169 if (err) 1170 goto out; 1171 1172 err = damon_sysfs_context_add_dirs(context); 1173 if (err) 1174 goto out; 1175 1176 contexts_arr[i] = context; 1177 contexts->nr++; 1178 } 1179 return 0; 1180 1181 out: 1182 damon_sysfs_contexts_rm_dirs(contexts); 1183 kobject_put(&context->kobj); 1184 return err; 1185 } 1186 1187 static ssize_t nr_contexts_show(struct kobject *kobj, 1188 struct kobj_attribute *attr, char *buf) 1189 { 1190 struct damon_sysfs_contexts *contexts = container_of(kobj, 1191 struct damon_sysfs_contexts, kobj); 1192 1193 return sysfs_emit(buf, "%d\n", contexts->nr); 1194 } 1195 1196 static ssize_t nr_contexts_store(struct kobject *kobj, 1197 struct kobj_attribute *attr, const char *buf, size_t count) 1198 { 1199 struct damon_sysfs_contexts *contexts; 1200 int nr, err; 1201 1202 err = kstrtoint(buf, 0, &nr); 1203 if (err) 1204 return err; 1205 /* TODO: support multiple contexts per kdamond */ 1206 if (nr < 0 || 1 < nr) 1207 return -EINVAL; 1208 1209 contexts = container_of(kobj, struct damon_sysfs_contexts, kobj); 1210 if (!mutex_trylock(&damon_sysfs_lock)) 1211 return -EBUSY; 1212 err = damon_sysfs_contexts_add_dirs(contexts, nr); 1213 mutex_unlock(&damon_sysfs_lock); 1214 if (err) 1215 return err; 1216 1217 return count; 1218 } 1219 1220 static void damon_sysfs_contexts_release(struct kobject *kobj) 1221 { 1222 kfree(container_of(kobj, struct damon_sysfs_contexts, kobj)); 1223 } 1224 1225 static struct kobj_attribute damon_sysfs_contexts_nr_attr 1226 = __ATTR_RW_MODE(nr_contexts, 0600); 1227 1228 static struct attribute *damon_sysfs_contexts_attrs[] = { 1229 &damon_sysfs_contexts_nr_attr.attr, 1230 NULL, 1231 }; 1232 ATTRIBUTE_GROUPS(damon_sysfs_contexts); 1233 1234 static const struct kobj_type damon_sysfs_contexts_ktype = { 1235 .release = damon_sysfs_contexts_release, 1236 .sysfs_ops = &kobj_sysfs_ops, 1237 .default_groups = damon_sysfs_contexts_groups, 1238 }; 1239 1240 /* 1241 * kdamond directory 1242 */ 1243 1244 struct damon_sysfs_kdamond { 1245 struct kobject kobj; 1246 struct damon_sysfs_contexts *contexts; 1247 struct damon_ctx *damon_ctx; 1248 unsigned int refresh_ms; 1249 }; 1250 1251 static struct damon_sysfs_kdamond *damon_sysfs_kdamond_alloc(void) 1252 { 1253 return kzalloc_obj(struct damon_sysfs_kdamond); 1254 } 1255 1256 static int damon_sysfs_kdamond_add_dirs(struct damon_sysfs_kdamond *kdamond) 1257 { 1258 struct damon_sysfs_contexts *contexts; 1259 int err; 1260 1261 contexts = damon_sysfs_contexts_alloc(); 1262 if (!contexts) 1263 return -ENOMEM; 1264 1265 err = kobject_init_and_add(&contexts->kobj, 1266 &damon_sysfs_contexts_ktype, &kdamond->kobj, 1267 "contexts"); 1268 if (err) { 1269 kobject_put(&contexts->kobj); 1270 return err; 1271 } 1272 kdamond->contexts = contexts; 1273 1274 return err; 1275 } 1276 1277 static void damon_sysfs_kdamond_rm_dirs(struct damon_sysfs_kdamond *kdamond) 1278 { 1279 damon_sysfs_contexts_rm_dirs(kdamond->contexts); 1280 kobject_put(&kdamond->contexts->kobj); 1281 } 1282 1283 /* 1284 * enum damon_sysfs_cmd - Commands for a specific kdamond. 1285 */ 1286 enum damon_sysfs_cmd { 1287 /* @DAMON_SYSFS_CMD_ON: Turn the kdamond on. */ 1288 DAMON_SYSFS_CMD_ON, 1289 /* @DAMON_SYSFS_CMD_OFF: Turn the kdamond off. */ 1290 DAMON_SYSFS_CMD_OFF, 1291 /* @DAMON_SYSFS_CMD_COMMIT: Update kdamond inputs. */ 1292 DAMON_SYSFS_CMD_COMMIT, 1293 /* 1294 * @DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS: Commit the quota goals 1295 * to DAMON. 1296 */ 1297 DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS, 1298 /* 1299 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS: Update scheme stats sysfs 1300 * files. 1301 */ 1302 DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS, 1303 /* 1304 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES: Update 1305 * tried_regions/total_bytes sysfs files for each scheme. 1306 */ 1307 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES, 1308 /* 1309 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS: Update schemes tried 1310 * regions 1311 */ 1312 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS, 1313 /* 1314 * @DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS: Clear schemes tried 1315 * regions 1316 */ 1317 DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS, 1318 /* 1319 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS: Update the 1320 * effective size quota of the scheme in bytes. 1321 */ 1322 DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS, 1323 /* 1324 * @DAMON_SYSFS_CMD_UPDATE_TUNED_INTERVALS: Update the tuned monitoring 1325 * intervals. 1326 */ 1327 DAMON_SYSFS_CMD_UPDATE_TUNED_INTERVALS, 1328 /* 1329 * @NR_DAMON_SYSFS_CMDS: Total number of DAMON sysfs commands. 1330 */ 1331 NR_DAMON_SYSFS_CMDS, 1332 }; 1333 1334 /* Should match with enum damon_sysfs_cmd */ 1335 static const char * const damon_sysfs_cmd_strs[] = { 1336 "on", 1337 "off", 1338 "commit", 1339 "commit_schemes_quota_goals", 1340 "update_schemes_stats", 1341 "update_schemes_tried_bytes", 1342 "update_schemes_tried_regions", 1343 "clear_schemes_tried_regions", 1344 "update_schemes_effective_quotas", 1345 "update_tuned_intervals", 1346 }; 1347 1348 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr, 1349 char *buf) 1350 { 1351 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1352 struct damon_sysfs_kdamond, kobj); 1353 struct damon_ctx *ctx; 1354 bool running = false; 1355 1356 if (!mutex_trylock(&damon_sysfs_lock)) 1357 return -EBUSY; 1358 1359 ctx = kdamond->damon_ctx; 1360 if (ctx) 1361 running = damon_is_running(ctx); 1362 1363 mutex_unlock(&damon_sysfs_lock); 1364 1365 return sysfs_emit(buf, "%s\n", running ? 1366 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_ON] : 1367 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_OFF]); 1368 } 1369 1370 static int damon_sysfs_set_attrs(struct damon_ctx *ctx, 1371 struct damon_sysfs_attrs *sys_attrs) 1372 { 1373 struct damon_sysfs_intervals *sys_intervals = sys_attrs->intervals; 1374 struct damon_sysfs_intervals_goal *sys_goal = 1375 sys_intervals->intervals_goal; 1376 struct damon_sysfs_ul_range *sys_nr_regions = 1377 sys_attrs->nr_regions_range; 1378 struct damon_attrs attrs = { 1379 .sample_interval = sys_intervals->sample_us, 1380 .aggr_interval = sys_intervals->aggr_us, 1381 .intervals_goal = { 1382 .access_bp = sys_goal->access_bp, 1383 .aggrs = sys_goal->aggrs, 1384 .min_sample_us = sys_goal->min_sample_us, 1385 .max_sample_us = sys_goal->max_sample_us}, 1386 .ops_update_interval = sys_intervals->update_us, 1387 .min_nr_regions = sys_nr_regions->min, 1388 .max_nr_regions = sys_nr_regions->max, 1389 }; 1390 return damon_set_attrs(ctx, &attrs); 1391 } 1392 1393 static int damon_sysfs_set_regions(struct damon_target *t, 1394 struct damon_sysfs_regions *sysfs_regions, 1395 unsigned long min_region_sz) 1396 { 1397 struct damon_addr_range *ranges = kmalloc_objs(*ranges, 1398 sysfs_regions->nr, 1399 GFP_KERNEL | __GFP_NOWARN); 1400 int i, err = -EINVAL; 1401 1402 if (!ranges) 1403 return -ENOMEM; 1404 for (i = 0; i < sysfs_regions->nr; i++) { 1405 struct damon_sysfs_region *sys_region = 1406 sysfs_regions->regions_arr[i]; 1407 1408 if (sys_region->ar.start > sys_region->ar.end) 1409 goto out; 1410 1411 ranges[i].start = sys_region->ar.start; 1412 ranges[i].end = sys_region->ar.end; 1413 if (i == 0) 1414 continue; 1415 if (ranges[i - 1].end > ranges[i].start) 1416 goto out; 1417 } 1418 err = damon_set_regions(t, ranges, sysfs_regions->nr, min_region_sz); 1419 out: 1420 kfree(ranges); 1421 return err; 1422 1423 } 1424 1425 static int damon_sysfs_add_target(struct damon_sysfs_target *sys_target, 1426 struct damon_ctx *ctx) 1427 { 1428 struct damon_target *t = damon_new_target(); 1429 1430 if (!t) 1431 return -ENOMEM; 1432 damon_add_target(ctx, t); 1433 if (damon_target_has_pid(ctx)) { 1434 t->pid = find_get_pid(sys_target->pid); 1435 if (!t->pid) 1436 /* caller will destroy targets */ 1437 return -EINVAL; 1438 } 1439 t->obsolete = sys_target->obsolete; 1440 return damon_sysfs_set_regions(t, sys_target->regions, 1441 ctx->min_region_sz); 1442 } 1443 1444 static int damon_sysfs_add_targets(struct damon_ctx *ctx, 1445 struct damon_sysfs_targets *sysfs_targets) 1446 { 1447 int i, err; 1448 1449 /* Multiple physical address space monitoring targets makes no sense */ 1450 if (ctx->ops.id == DAMON_OPS_PADDR && sysfs_targets->nr > 1) 1451 return -EINVAL; 1452 1453 for (i = 0; i < sysfs_targets->nr; i++) { 1454 struct damon_sysfs_target *st = sysfs_targets->targets_arr[i]; 1455 1456 err = damon_sysfs_add_target(st, ctx); 1457 if (err) 1458 return err; 1459 } 1460 return 0; 1461 } 1462 1463 /* 1464 * damon_sysfs_upd_schemes_stats() - Update schemes stats sysfs files. 1465 * @data: The kobject wrapper that associated to the kdamond thread. 1466 * 1467 * This function reads the schemes stats of specific kdamond and update the 1468 * related values for sysfs files. This function should be called from DAMON 1469 * worker thread,to safely access the DAMON contexts-internal data. Caller 1470 * should also ensure holding ``damon_syfs_lock``, and ->damon_ctx of @data is 1471 * not NULL but a valid pointer, to safely access DAMON sysfs variables. 1472 */ 1473 static int damon_sysfs_upd_schemes_stats(void *data) 1474 { 1475 struct damon_sysfs_kdamond *kdamond = data; 1476 struct damon_ctx *ctx = kdamond->damon_ctx; 1477 1478 damon_sysfs_schemes_update_stats( 1479 kdamond->contexts->contexts_arr[0]->schemes, ctx); 1480 return 0; 1481 } 1482 1483 static inline bool damon_sysfs_kdamond_running( 1484 struct damon_sysfs_kdamond *kdamond) 1485 { 1486 return kdamond->damon_ctx && 1487 damon_is_running(kdamond->damon_ctx); 1488 } 1489 1490 static int damon_sysfs_apply_inputs(struct damon_ctx *ctx, 1491 struct damon_sysfs_context *sys_ctx) 1492 { 1493 int err; 1494 1495 err = damon_select_ops(ctx, sys_ctx->ops_id); 1496 if (err) 1497 return err; 1498 ctx->addr_unit = sys_ctx->addr_unit; 1499 /* addr_unit is respected by only DAMON_OPS_PADDR */ 1500 if (sys_ctx->ops_id == DAMON_OPS_PADDR) 1501 ctx->min_region_sz = max( 1502 DAMON_MIN_REGION_SZ / sys_ctx->addr_unit, 1); 1503 ctx->pause = sys_ctx->pause; 1504 err = damon_sysfs_set_attrs(ctx, sys_ctx->attrs); 1505 if (err) 1506 return err; 1507 err = damon_sysfs_add_targets(ctx, sys_ctx->targets); 1508 if (err) 1509 return err; 1510 return damon_sysfs_add_schemes(ctx, sys_ctx->schemes); 1511 } 1512 1513 static struct damon_ctx *damon_sysfs_build_ctx( 1514 struct damon_sysfs_context *sys_ctx); 1515 1516 /* 1517 * Return a new damon_ctx for testing new parameters to commit. 1518 */ 1519 static struct damon_ctx *damon_sysfs_new_test_ctx( 1520 struct damon_ctx *running_ctx) 1521 { 1522 struct damon_ctx *test_ctx; 1523 int err; 1524 1525 test_ctx = damon_new_ctx(); 1526 if (!test_ctx) 1527 return NULL; 1528 err = damon_commit_ctx(test_ctx, running_ctx); 1529 if (err) { 1530 damon_destroy_ctx(test_ctx); 1531 return NULL; 1532 } 1533 return test_ctx; 1534 } 1535 1536 /* 1537 * damon_sysfs_commit_input() - Commit user inputs to a running kdamond. 1538 * @kdamond: The kobject wrapper for the associated kdamond. 1539 * 1540 * Returns error if the sysfs input is wrong. 1541 */ 1542 static int damon_sysfs_commit_input(void *data) 1543 { 1544 struct damon_sysfs_kdamond *kdamond = data; 1545 struct damon_ctx *param_ctx, *test_ctx; 1546 int err; 1547 1548 if (!damon_sysfs_kdamond_running(kdamond)) 1549 return -EINVAL; 1550 /* TODO: Support multiple contexts per kdamond */ 1551 if (kdamond->contexts->nr != 1) 1552 return -EINVAL; 1553 1554 param_ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]); 1555 if (IS_ERR(param_ctx)) 1556 return PTR_ERR(param_ctx); 1557 test_ctx = damon_sysfs_new_test_ctx(kdamond->damon_ctx); 1558 if (!test_ctx) { 1559 damon_destroy_ctx(param_ctx); 1560 return -ENOMEM; 1561 } 1562 err = damon_commit_ctx(test_ctx, param_ctx); 1563 if (err) 1564 goto out; 1565 err = damon_commit_ctx(kdamond->damon_ctx, param_ctx); 1566 out: 1567 damon_destroy_ctx(test_ctx); 1568 damon_destroy_ctx(param_ctx); 1569 return err; 1570 } 1571 1572 static int damon_sysfs_commit_schemes_quota_goals(void *data) 1573 { 1574 struct damon_sysfs_kdamond *sysfs_kdamond = data; 1575 struct damon_ctx *ctx; 1576 struct damon_sysfs_context *sysfs_ctx; 1577 1578 if (!damon_sysfs_kdamond_running(sysfs_kdamond)) 1579 return -EINVAL; 1580 /* TODO: Support multiple contexts per kdamond */ 1581 if (sysfs_kdamond->contexts->nr != 1) 1582 return -EINVAL; 1583 1584 ctx = sysfs_kdamond->damon_ctx; 1585 sysfs_ctx = sysfs_kdamond->contexts->contexts_arr[0]; 1586 return damos_sysfs_set_quota_scores(sysfs_ctx->schemes, ctx); 1587 } 1588 1589 /* 1590 * damon_sysfs_upd_schemes_effective_quotas() - Update schemes effective quotas 1591 * sysfs files. 1592 * @data: The kobject wrapper that associated to the kdamond thread. 1593 * 1594 * This function reads the schemes' effective quotas of specific kdamond and 1595 * update the related values for sysfs files. This function should be called 1596 * from DAMON callbacks while holding ``damon_syfs_lock``, to safely access the 1597 * DAMON contexts-internal data and DAMON sysfs variables. 1598 */ 1599 static int damon_sysfs_upd_schemes_effective_quotas(void *data) 1600 { 1601 struct damon_sysfs_kdamond *kdamond = data; 1602 struct damon_ctx *ctx = kdamond->damon_ctx; 1603 1604 damos_sysfs_update_effective_quotas( 1605 kdamond->contexts->contexts_arr[0]->schemes, ctx); 1606 return 0; 1607 } 1608 1609 static int damon_sysfs_upd_tuned_intervals(void *data) 1610 { 1611 struct damon_sysfs_kdamond *kdamond = data; 1612 struct damon_ctx *ctx = kdamond->damon_ctx; 1613 1614 kdamond->contexts->contexts_arr[0]->attrs->intervals->sample_us = 1615 ctx->attrs.sample_interval; 1616 kdamond->contexts->contexts_arr[0]->attrs->intervals->aggr_us = 1617 ctx->attrs.aggr_interval; 1618 return 0; 1619 } 1620 1621 static struct damon_ctx *damon_sysfs_build_ctx( 1622 struct damon_sysfs_context *sys_ctx) 1623 { 1624 struct damon_ctx *ctx = damon_new_ctx(); 1625 int err; 1626 1627 if (!ctx) 1628 return ERR_PTR(-ENOMEM); 1629 1630 err = damon_sysfs_apply_inputs(ctx, sys_ctx); 1631 if (err) { 1632 damon_destroy_ctx(ctx); 1633 return ERR_PTR(err); 1634 } 1635 1636 return ctx; 1637 } 1638 1639 static unsigned long damon_sysfs_next_update_jiffies; 1640 1641 static int damon_sysfs_repeat_call_fn(void *data) 1642 { 1643 struct damon_sysfs_kdamond *sysfs_kdamond = data; 1644 1645 if (!sysfs_kdamond->refresh_ms) 1646 return 0; 1647 if (time_before(jiffies, damon_sysfs_next_update_jiffies)) 1648 return 0; 1649 damon_sysfs_next_update_jiffies = jiffies + 1650 msecs_to_jiffies(sysfs_kdamond->refresh_ms); 1651 1652 if (!mutex_trylock(&damon_sysfs_lock)) 1653 return 0; 1654 if (sysfs_kdamond->contexts->nr != 1) 1655 goto out; 1656 damon_sysfs_upd_tuned_intervals(sysfs_kdamond); 1657 damon_sysfs_upd_schemes_stats(sysfs_kdamond); 1658 damon_sysfs_upd_schemes_effective_quotas(sysfs_kdamond); 1659 out: 1660 mutex_unlock(&damon_sysfs_lock); 1661 return 0; 1662 } 1663 1664 static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond) 1665 { 1666 struct damon_ctx *ctx; 1667 struct damon_call_control *repeat_call_control; 1668 int err; 1669 1670 if (damon_sysfs_kdamond_running(kdamond)) 1671 return -EBUSY; 1672 /* TODO: support multiple contexts per kdamond */ 1673 if (kdamond->contexts->nr != 1) 1674 return -EINVAL; 1675 1676 if (kdamond->damon_ctx) 1677 damon_destroy_ctx(kdamond->damon_ctx); 1678 kdamond->damon_ctx = NULL; 1679 1680 repeat_call_control = kmalloc_obj(*repeat_call_control); 1681 if (!repeat_call_control) 1682 return -ENOMEM; 1683 1684 ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]); 1685 if (IS_ERR(ctx)) { 1686 kfree(repeat_call_control); 1687 return PTR_ERR(ctx); 1688 } 1689 err = damon_start(&ctx, 1, false); 1690 if (err) { 1691 kfree(repeat_call_control); 1692 damon_destroy_ctx(ctx); 1693 return err; 1694 } 1695 kdamond->damon_ctx = ctx; 1696 1697 damon_sysfs_next_update_jiffies = 1698 jiffies + msecs_to_jiffies(kdamond->refresh_ms); 1699 1700 repeat_call_control->fn = damon_sysfs_repeat_call_fn; 1701 repeat_call_control->data = kdamond; 1702 repeat_call_control->repeat = true; 1703 repeat_call_control->dealloc_on_cancel = true; 1704 if (damon_call(ctx, repeat_call_control)) 1705 kfree(repeat_call_control); 1706 return err; 1707 } 1708 1709 static int damon_sysfs_turn_damon_off(struct damon_sysfs_kdamond *kdamond) 1710 { 1711 if (!kdamond->damon_ctx) 1712 return -EINVAL; 1713 return damon_stop(&kdamond->damon_ctx, 1); 1714 /* 1715 * To allow users show final monitoring results of already turned-off 1716 * DAMON, we free kdamond->damon_ctx in next 1717 * damon_sysfs_turn_damon_on(), or kdamonds_nr_store() 1718 */ 1719 } 1720 1721 static int damon_sysfs_damon_call(int (*fn)(void *data), 1722 struct damon_sysfs_kdamond *kdamond) 1723 { 1724 struct damon_call_control call_control = {}; 1725 int err; 1726 1727 if (!kdamond->damon_ctx) 1728 return -EINVAL; 1729 call_control.fn = fn; 1730 call_control.data = kdamond; 1731 err = damon_call(kdamond->damon_ctx, &call_control); 1732 return err ? err : call_control.return_code; 1733 } 1734 1735 struct damon_sysfs_schemes_walk_data { 1736 struct damon_sysfs_kdamond *sysfs_kdamond; 1737 bool total_bytes_only; 1738 }; 1739 1740 /* populate the region directory */ 1741 static void damon_sysfs_schemes_tried_regions_upd_one(void *data, struct damon_ctx *ctx, 1742 struct damon_target *t, struct damon_region *r, 1743 struct damos *s, unsigned long sz_filter_passed) 1744 { 1745 struct damon_sysfs_schemes_walk_data *walk_data = data; 1746 struct damon_sysfs_kdamond *sysfs_kdamond = walk_data->sysfs_kdamond; 1747 1748 damos_sysfs_populate_region_dir( 1749 sysfs_kdamond->contexts->contexts_arr[0]->schemes, 1750 ctx, t, r, s, walk_data->total_bytes_only, 1751 sz_filter_passed); 1752 } 1753 1754 static int damon_sysfs_update_schemes_tried_regions( 1755 struct damon_sysfs_kdamond *sysfs_kdamond, bool total_bytes_only) 1756 { 1757 struct damon_sysfs_schemes_walk_data walk_data = { 1758 .sysfs_kdamond = sysfs_kdamond, 1759 .total_bytes_only = total_bytes_only, 1760 }; 1761 struct damos_walk_control control = { 1762 .walk_fn = damon_sysfs_schemes_tried_regions_upd_one, 1763 .data = &walk_data, 1764 }; 1765 struct damon_ctx *ctx = sysfs_kdamond->damon_ctx; 1766 1767 if (!ctx) 1768 return -EINVAL; 1769 1770 damon_sysfs_schemes_clear_regions( 1771 sysfs_kdamond->contexts->contexts_arr[0]->schemes); 1772 return damos_walk(ctx, &control); 1773 } 1774 1775 /* 1776 * damon_sysfs_handle_cmd() - Handle a command for a specific kdamond. 1777 * @cmd: The command to handle. 1778 * @kdamond: The kobject wrapper for the associated kdamond. 1779 * 1780 * This function handles a DAMON sysfs command for a kdamond. 1781 * 1782 * Return: 0 on success, negative error code otherwise. 1783 */ 1784 static int damon_sysfs_handle_cmd(enum damon_sysfs_cmd cmd, 1785 struct damon_sysfs_kdamond *kdamond) 1786 { 1787 if (cmd != DAMON_SYSFS_CMD_OFF && kdamond->contexts->nr != 1) 1788 return -EINVAL; 1789 1790 switch (cmd) { 1791 case DAMON_SYSFS_CMD_ON: 1792 return damon_sysfs_turn_damon_on(kdamond); 1793 case DAMON_SYSFS_CMD_OFF: 1794 return damon_sysfs_turn_damon_off(kdamond); 1795 case DAMON_SYSFS_CMD_COMMIT: 1796 return damon_sysfs_damon_call( 1797 damon_sysfs_commit_input, kdamond); 1798 case DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS: 1799 return damon_sysfs_damon_call( 1800 damon_sysfs_commit_schemes_quota_goals, 1801 kdamond); 1802 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS: 1803 return damon_sysfs_damon_call( 1804 damon_sysfs_upd_schemes_stats, kdamond); 1805 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES: 1806 return damon_sysfs_update_schemes_tried_regions(kdamond, true); 1807 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS: 1808 return damon_sysfs_update_schemes_tried_regions(kdamond, false); 1809 case DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS: 1810 return damon_sysfs_schemes_clear_regions( 1811 kdamond->contexts->contexts_arr[0]->schemes); 1812 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS: 1813 return damon_sysfs_damon_call( 1814 damon_sysfs_upd_schemes_effective_quotas, 1815 kdamond); 1816 case DAMON_SYSFS_CMD_UPDATE_TUNED_INTERVALS: 1817 return damon_sysfs_damon_call( 1818 damon_sysfs_upd_tuned_intervals, kdamond); 1819 default: 1820 return -EINVAL; 1821 } 1822 } 1823 1824 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr, 1825 const char *buf, size_t count) 1826 { 1827 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1828 struct damon_sysfs_kdamond, kobj); 1829 enum damon_sysfs_cmd cmd; 1830 ssize_t ret = -EINVAL; 1831 1832 if (!mutex_trylock(&damon_sysfs_lock)) 1833 return -EBUSY; 1834 for (cmd = 0; cmd < NR_DAMON_SYSFS_CMDS; cmd++) { 1835 if (sysfs_streq(buf, damon_sysfs_cmd_strs[cmd])) { 1836 ret = damon_sysfs_handle_cmd(cmd, kdamond); 1837 break; 1838 } 1839 } 1840 mutex_unlock(&damon_sysfs_lock); 1841 if (!ret) 1842 ret = count; 1843 return ret; 1844 } 1845 1846 static ssize_t pid_show(struct kobject *kobj, 1847 struct kobj_attribute *attr, char *buf) 1848 { 1849 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1850 struct damon_sysfs_kdamond, kobj); 1851 struct damon_ctx *ctx; 1852 int pid = -1; 1853 1854 if (!mutex_trylock(&damon_sysfs_lock)) 1855 return -EBUSY; 1856 ctx = kdamond->damon_ctx; 1857 if (!ctx) 1858 goto out; 1859 1860 pid = damon_kdamond_pid(ctx); 1861 if (pid < 0) 1862 pid = -1; 1863 out: 1864 mutex_unlock(&damon_sysfs_lock); 1865 return sysfs_emit(buf, "%d\n", pid); 1866 } 1867 1868 static ssize_t refresh_ms_show(struct kobject *kobj, 1869 struct kobj_attribute *attr, char *buf) 1870 { 1871 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1872 struct damon_sysfs_kdamond, kobj); 1873 1874 return sysfs_emit(buf, "%u\n", kdamond->refresh_ms); 1875 } 1876 1877 static ssize_t refresh_ms_store(struct kobject *kobj, 1878 struct kobj_attribute *attr, const char *buf, size_t count) 1879 { 1880 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1881 struct damon_sysfs_kdamond, kobj); 1882 unsigned int nr; 1883 int err = kstrtouint(buf, 0, &nr); 1884 1885 if (err) 1886 return err; 1887 1888 kdamond->refresh_ms = nr; 1889 return count; 1890 } 1891 1892 static void damon_sysfs_kdamond_release(struct kobject *kobj) 1893 { 1894 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1895 struct damon_sysfs_kdamond, kobj); 1896 1897 if (kdamond->damon_ctx) 1898 damon_destroy_ctx(kdamond->damon_ctx); 1899 kfree(kdamond); 1900 } 1901 1902 static struct kobj_attribute damon_sysfs_kdamond_state_attr = 1903 __ATTR_RW_MODE(state, 0600); 1904 1905 static struct kobj_attribute damon_sysfs_kdamond_pid_attr = 1906 __ATTR_RO_MODE(pid, 0400); 1907 1908 static struct kobj_attribute damon_sysfs_kdamond_refresh_ms_attr = 1909 __ATTR_RW_MODE(refresh_ms, 0600); 1910 1911 static struct attribute *damon_sysfs_kdamond_attrs[] = { 1912 &damon_sysfs_kdamond_state_attr.attr, 1913 &damon_sysfs_kdamond_pid_attr.attr, 1914 &damon_sysfs_kdamond_refresh_ms_attr.attr, 1915 NULL, 1916 }; 1917 ATTRIBUTE_GROUPS(damon_sysfs_kdamond); 1918 1919 static const struct kobj_type damon_sysfs_kdamond_ktype = { 1920 .release = damon_sysfs_kdamond_release, 1921 .sysfs_ops = &kobj_sysfs_ops, 1922 .default_groups = damon_sysfs_kdamond_groups, 1923 }; 1924 1925 /* 1926 * kdamonds directory 1927 */ 1928 1929 struct damon_sysfs_kdamonds { 1930 struct kobject kobj; 1931 struct damon_sysfs_kdamond **kdamonds_arr; 1932 int nr; 1933 }; 1934 1935 static struct damon_sysfs_kdamonds *damon_sysfs_kdamonds_alloc(void) 1936 { 1937 return kzalloc_obj(struct damon_sysfs_kdamonds); 1938 } 1939 1940 static void damon_sysfs_kdamonds_rm_dirs(struct damon_sysfs_kdamonds *kdamonds) 1941 { 1942 struct damon_sysfs_kdamond **kdamonds_arr = kdamonds->kdamonds_arr; 1943 int i; 1944 1945 for (i = 0; i < kdamonds->nr; i++) { 1946 damon_sysfs_kdamond_rm_dirs(kdamonds_arr[i]); 1947 kobject_put(&kdamonds_arr[i]->kobj); 1948 } 1949 kdamonds->nr = 0; 1950 kfree(kdamonds_arr); 1951 kdamonds->kdamonds_arr = NULL; 1952 } 1953 1954 static bool damon_sysfs_kdamonds_busy(struct damon_sysfs_kdamond **kdamonds, 1955 int nr_kdamonds) 1956 { 1957 int i; 1958 1959 for (i = 0; i < nr_kdamonds; i++) { 1960 if (damon_sysfs_kdamond_running(kdamonds[i])) 1961 return true; 1962 } 1963 1964 return false; 1965 } 1966 1967 static int damon_sysfs_kdamonds_add_dirs(struct damon_sysfs_kdamonds *kdamonds, 1968 int nr_kdamonds) 1969 { 1970 struct damon_sysfs_kdamond **kdamonds_arr, *kdamond; 1971 int err, i; 1972 1973 if (damon_sysfs_kdamonds_busy(kdamonds->kdamonds_arr, kdamonds->nr)) 1974 return -EBUSY; 1975 1976 damon_sysfs_kdamonds_rm_dirs(kdamonds); 1977 if (!nr_kdamonds) 1978 return 0; 1979 1980 kdamonds_arr = kmalloc_objs(*kdamonds_arr, nr_kdamonds, 1981 GFP_KERNEL | __GFP_NOWARN); 1982 if (!kdamonds_arr) 1983 return -ENOMEM; 1984 kdamonds->kdamonds_arr = kdamonds_arr; 1985 1986 for (i = 0; i < nr_kdamonds; i++) { 1987 kdamond = damon_sysfs_kdamond_alloc(); 1988 if (!kdamond) { 1989 damon_sysfs_kdamonds_rm_dirs(kdamonds); 1990 return -ENOMEM; 1991 } 1992 1993 err = kobject_init_and_add(&kdamond->kobj, 1994 &damon_sysfs_kdamond_ktype, &kdamonds->kobj, 1995 "%d", i); 1996 if (err) 1997 goto out; 1998 1999 err = damon_sysfs_kdamond_add_dirs(kdamond); 2000 if (err) 2001 goto out; 2002 2003 kdamonds_arr[i] = kdamond; 2004 kdamonds->nr++; 2005 } 2006 return 0; 2007 2008 out: 2009 damon_sysfs_kdamonds_rm_dirs(kdamonds); 2010 kobject_put(&kdamond->kobj); 2011 return err; 2012 } 2013 2014 static ssize_t nr_kdamonds_show(struct kobject *kobj, 2015 struct kobj_attribute *attr, char *buf) 2016 { 2017 struct damon_sysfs_kdamonds *kdamonds = container_of(kobj, 2018 struct damon_sysfs_kdamonds, kobj); 2019 2020 return sysfs_emit(buf, "%d\n", kdamonds->nr); 2021 } 2022 2023 static ssize_t nr_kdamonds_store(struct kobject *kobj, 2024 struct kobj_attribute *attr, const char *buf, size_t count) 2025 { 2026 struct damon_sysfs_kdamonds *kdamonds; 2027 int nr, err; 2028 2029 err = kstrtoint(buf, 0, &nr); 2030 if (err) 2031 return err; 2032 if (nr < 0) 2033 return -EINVAL; 2034 2035 kdamonds = container_of(kobj, struct damon_sysfs_kdamonds, kobj); 2036 2037 if (!mutex_trylock(&damon_sysfs_lock)) 2038 return -EBUSY; 2039 err = damon_sysfs_kdamonds_add_dirs(kdamonds, nr); 2040 mutex_unlock(&damon_sysfs_lock); 2041 if (err) 2042 return err; 2043 2044 return count; 2045 } 2046 2047 static void damon_sysfs_kdamonds_release(struct kobject *kobj) 2048 { 2049 kfree(container_of(kobj, struct damon_sysfs_kdamonds, kobj)); 2050 } 2051 2052 static struct kobj_attribute damon_sysfs_kdamonds_nr_attr = 2053 __ATTR_RW_MODE(nr_kdamonds, 0600); 2054 2055 static struct attribute *damon_sysfs_kdamonds_attrs[] = { 2056 &damon_sysfs_kdamonds_nr_attr.attr, 2057 NULL, 2058 }; 2059 ATTRIBUTE_GROUPS(damon_sysfs_kdamonds); 2060 2061 static const struct kobj_type damon_sysfs_kdamonds_ktype = { 2062 .release = damon_sysfs_kdamonds_release, 2063 .sysfs_ops = &kobj_sysfs_ops, 2064 .default_groups = damon_sysfs_kdamonds_groups, 2065 }; 2066 2067 /* 2068 * damon user interface directory 2069 */ 2070 2071 struct damon_sysfs_ui_dir { 2072 struct kobject kobj; 2073 struct damon_sysfs_kdamonds *kdamonds; 2074 }; 2075 2076 static struct damon_sysfs_ui_dir *damon_sysfs_ui_dir_alloc(void) 2077 { 2078 return kzalloc_obj(struct damon_sysfs_ui_dir); 2079 } 2080 2081 static int damon_sysfs_ui_dir_add_dirs(struct damon_sysfs_ui_dir *ui_dir) 2082 { 2083 struct damon_sysfs_kdamonds *kdamonds; 2084 int err; 2085 2086 kdamonds = damon_sysfs_kdamonds_alloc(); 2087 if (!kdamonds) 2088 return -ENOMEM; 2089 2090 err = kobject_init_and_add(&kdamonds->kobj, 2091 &damon_sysfs_kdamonds_ktype, &ui_dir->kobj, 2092 "kdamonds"); 2093 if (err) { 2094 kobject_put(&kdamonds->kobj); 2095 return err; 2096 } 2097 ui_dir->kdamonds = kdamonds; 2098 return err; 2099 } 2100 2101 static void damon_sysfs_ui_dir_release(struct kobject *kobj) 2102 { 2103 kfree(container_of(kobj, struct damon_sysfs_ui_dir, kobj)); 2104 } 2105 2106 static struct attribute *damon_sysfs_ui_dir_attrs[] = { 2107 NULL, 2108 }; 2109 ATTRIBUTE_GROUPS(damon_sysfs_ui_dir); 2110 2111 static const struct kobj_type damon_sysfs_ui_dir_ktype = { 2112 .release = damon_sysfs_ui_dir_release, 2113 .sysfs_ops = &kobj_sysfs_ops, 2114 .default_groups = damon_sysfs_ui_dir_groups, 2115 }; 2116 2117 static int __init damon_sysfs_init(void) 2118 { 2119 struct kobject *damon_sysfs_root; 2120 struct damon_sysfs_ui_dir *admin; 2121 int err; 2122 2123 damon_sysfs_root = kobject_create_and_add("damon", mm_kobj); 2124 if (!damon_sysfs_root) 2125 return -ENOMEM; 2126 2127 admin = damon_sysfs_ui_dir_alloc(); 2128 if (!admin) { 2129 kobject_put(damon_sysfs_root); 2130 return -ENOMEM; 2131 } 2132 err = kobject_init_and_add(&admin->kobj, &damon_sysfs_ui_dir_ktype, 2133 damon_sysfs_root, "admin"); 2134 if (err) 2135 goto out; 2136 err = damon_sysfs_ui_dir_add_dirs(admin); 2137 if (err) 2138 goto out; 2139 return 0; 2140 2141 out: 2142 kobject_put(&admin->kobj); 2143 kobject_put(damon_sysfs_root); 2144 return err; 2145 } 2146 subsys_initcall(damon_sysfs_init); 2147 2148 #include "tests/sysfs-kunit.h" 2149