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