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