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