1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * DAMON sysfs Interface 4 * 5 * Copyright (c) 2022 SeongJae Park <sj@kernel.org> 6 */ 7 8 #include <linux/pid.h> 9 #include <linux/sched.h> 10 #include <linux/slab.h> 11 12 #include "sysfs-common.h" 13 14 /* 15 * init region directory 16 */ 17 18 struct damon_sysfs_region { 19 struct kobject kobj; 20 struct damon_addr_range ar; 21 }; 22 23 static struct damon_sysfs_region *damon_sysfs_region_alloc(void) 24 { 25 return kzalloc_obj(struct damon_sysfs_region); 26 } 27 28 static ssize_t start_show(struct kobject *kobj, struct kobj_attribute *attr, 29 char *buf) 30 { 31 struct damon_sysfs_region *region = container_of(kobj, 32 struct damon_sysfs_region, kobj); 33 34 return sysfs_emit(buf, "%lu\n", region->ar.start); 35 } 36 37 static ssize_t start_store(struct kobject *kobj, struct kobj_attribute *attr, 38 const char *buf, size_t count) 39 { 40 struct damon_sysfs_region *region = container_of(kobj, 41 struct damon_sysfs_region, kobj); 42 int err = kstrtoul(buf, 0, ®ion->ar.start); 43 44 return err ? err : count; 45 } 46 47 static ssize_t end_show(struct kobject *kobj, struct kobj_attribute *attr, 48 char *buf) 49 { 50 struct damon_sysfs_region *region = container_of(kobj, 51 struct damon_sysfs_region, kobj); 52 53 return sysfs_emit(buf, "%lu\n", region->ar.end); 54 } 55 56 static ssize_t end_store(struct kobject *kobj, struct kobj_attribute *attr, 57 const char *buf, size_t count) 58 { 59 struct damon_sysfs_region *region = container_of(kobj, 60 struct damon_sysfs_region, kobj); 61 int err = kstrtoul(buf, 0, ®ion->ar.end); 62 63 return err ? err : count; 64 } 65 66 static void damon_sysfs_region_release(struct kobject *kobj) 67 { 68 kfree(container_of(kobj, struct damon_sysfs_region, kobj)); 69 } 70 71 static struct kobj_attribute damon_sysfs_region_start_attr = 72 __ATTR_RW_MODE(start, 0600); 73 74 static struct kobj_attribute damon_sysfs_region_end_attr = 75 __ATTR_RW_MODE(end, 0600); 76 77 static struct attribute *damon_sysfs_region_attrs[] = { 78 &damon_sysfs_region_start_attr.attr, 79 &damon_sysfs_region_end_attr.attr, 80 NULL, 81 }; 82 ATTRIBUTE_GROUPS(damon_sysfs_region); 83 84 static const struct kobj_type damon_sysfs_region_ktype = { 85 .release = damon_sysfs_region_release, 86 .sysfs_ops = &kobj_sysfs_ops, 87 .default_groups = damon_sysfs_region_groups, 88 }; 89 90 /* 91 * init_regions directory 92 */ 93 94 struct damon_sysfs_regions { 95 struct kobject kobj; 96 struct damon_sysfs_region **regions_arr; 97 int nr; 98 }; 99 100 static struct damon_sysfs_regions *damon_sysfs_regions_alloc(void) 101 { 102 return kzalloc_obj(struct damon_sysfs_regions); 103 } 104 105 static void damon_sysfs_regions_rm_dirs(struct damon_sysfs_regions *regions) 106 { 107 struct damon_sysfs_region **regions_arr = regions->regions_arr; 108 int i; 109 110 for (i = 0; i < regions->nr; i++) 111 kobject_put(®ions_arr[i]->kobj); 112 regions->nr = 0; 113 kfree(regions_arr); 114 regions->regions_arr = NULL; 115 } 116 117 static int damon_sysfs_regions_add_dirs(struct damon_sysfs_regions *regions, 118 int nr_regions) 119 { 120 struct damon_sysfs_region **regions_arr, *region; 121 int err, i; 122 123 damon_sysfs_regions_rm_dirs(regions); 124 if (!nr_regions) 125 return 0; 126 127 regions_arr = kmalloc_objs(*regions_arr, nr_regions, 128 GFP_KERNEL | __GFP_NOWARN); 129 if (!regions_arr) 130 return -ENOMEM; 131 regions->regions_arr = regions_arr; 132 133 for (i = 0; i < nr_regions; i++) { 134 region = damon_sysfs_region_alloc(); 135 if (!region) { 136 damon_sysfs_regions_rm_dirs(regions); 137 return -ENOMEM; 138 } 139 140 err = kobject_init_and_add(®ion->kobj, 141 &damon_sysfs_region_ktype, ®ions->kobj, 142 "%d", i); 143 if (err) { 144 kobject_put(®ion->kobj); 145 damon_sysfs_regions_rm_dirs(regions); 146 return err; 147 } 148 149 regions_arr[i] = region; 150 regions->nr++; 151 } 152 return 0; 153 } 154 155 static ssize_t nr_regions_show(struct kobject *kobj, 156 struct kobj_attribute *attr, char *buf) 157 { 158 struct damon_sysfs_regions *regions = container_of(kobj, 159 struct damon_sysfs_regions, kobj); 160 161 return sysfs_emit(buf, "%d\n", regions->nr); 162 } 163 164 static ssize_t nr_regions_store(struct kobject *kobj, 165 struct kobj_attribute *attr, const char *buf, size_t count) 166 { 167 struct damon_sysfs_regions *regions; 168 int nr, err = kstrtoint(buf, 0, &nr); 169 170 if (err) 171 return err; 172 if (nr < 0) 173 return -EINVAL; 174 175 regions = container_of(kobj, struct damon_sysfs_regions, kobj); 176 177 if (!mutex_trylock(&damon_sysfs_lock)) 178 return -EBUSY; 179 err = damon_sysfs_regions_add_dirs(regions, nr); 180 mutex_unlock(&damon_sysfs_lock); 181 if (err) 182 return err; 183 184 return count; 185 } 186 187 static void damon_sysfs_regions_release(struct kobject *kobj) 188 { 189 kfree(container_of(kobj, struct damon_sysfs_regions, kobj)); 190 } 191 192 static struct kobj_attribute damon_sysfs_regions_nr_attr = 193 __ATTR_RW_MODE(nr_regions, 0600); 194 195 static struct attribute *damon_sysfs_regions_attrs[] = { 196 &damon_sysfs_regions_nr_attr.attr, 197 NULL, 198 }; 199 ATTRIBUTE_GROUPS(damon_sysfs_regions); 200 201 static const struct kobj_type damon_sysfs_regions_ktype = { 202 .release = damon_sysfs_regions_release, 203 .sysfs_ops = &kobj_sysfs_ops, 204 .default_groups = damon_sysfs_regions_groups, 205 }; 206 207 /* 208 * target directory 209 */ 210 211 struct damon_sysfs_target { 212 struct kobject kobj; 213 struct damon_sysfs_regions *regions; 214 int pid; 215 bool obsolete; 216 }; 217 218 static struct damon_sysfs_target *damon_sysfs_target_alloc(void) 219 { 220 return kzalloc_obj(struct damon_sysfs_target); 221 } 222 223 static int damon_sysfs_target_add_dirs(struct damon_sysfs_target *target) 224 { 225 struct damon_sysfs_regions *regions = damon_sysfs_regions_alloc(); 226 int err; 227 228 if (!regions) 229 return -ENOMEM; 230 231 err = kobject_init_and_add(®ions->kobj, &damon_sysfs_regions_ktype, 232 &target->kobj, "regions"); 233 if (err) 234 kobject_put(®ions->kobj); 235 else 236 target->regions = regions; 237 return err; 238 } 239 240 static void damon_sysfs_target_rm_dirs(struct damon_sysfs_target *target) 241 { 242 damon_sysfs_regions_rm_dirs(target->regions); 243 kobject_put(&target->regions->kobj); 244 } 245 246 static ssize_t pid_target_show(struct kobject *kobj, 247 struct kobj_attribute *attr, char *buf) 248 { 249 struct damon_sysfs_target *target = container_of(kobj, 250 struct damon_sysfs_target, kobj); 251 252 return sysfs_emit(buf, "%d\n", target->pid); 253 } 254 255 static ssize_t pid_target_store(struct kobject *kobj, 256 struct kobj_attribute *attr, const char *buf, size_t count) 257 { 258 struct damon_sysfs_target *target = container_of(kobj, 259 struct damon_sysfs_target, kobj); 260 int err = kstrtoint(buf, 0, &target->pid); 261 262 if (err) 263 return -EINVAL; 264 return count; 265 } 266 267 static ssize_t obsolete_target_show(struct kobject *kobj, 268 struct kobj_attribute *attr, char *buf) 269 { 270 struct damon_sysfs_target *target = container_of(kobj, 271 struct damon_sysfs_target, kobj); 272 273 return sysfs_emit(buf, "%c\n", target->obsolete ? 'Y' : 'N'); 274 } 275 276 static ssize_t obsolete_target_store(struct kobject *kobj, 277 struct kobj_attribute *attr, const char *buf, size_t count) 278 { 279 struct damon_sysfs_target *target = container_of(kobj, 280 struct damon_sysfs_target, kobj); 281 bool obsolete; 282 int err = kstrtobool(buf, &obsolete); 283 284 if (err) 285 return err; 286 target->obsolete = obsolete; 287 return count; 288 } 289 290 static void damon_sysfs_target_release(struct kobject *kobj) 291 { 292 kfree(container_of(kobj, struct damon_sysfs_target, kobj)); 293 } 294 295 static struct kobj_attribute damon_sysfs_target_pid_attr = 296 __ATTR_RW_MODE(pid_target, 0600); 297 298 static struct kobj_attribute damon_sysfs_target_obsolete_attr = 299 __ATTR_RW_MODE(obsolete_target, 0600); 300 301 static struct attribute *damon_sysfs_target_attrs[] = { 302 &damon_sysfs_target_pid_attr.attr, 303 &damon_sysfs_target_obsolete_attr.attr, 304 NULL, 305 }; 306 ATTRIBUTE_GROUPS(damon_sysfs_target); 307 308 static const struct kobj_type damon_sysfs_target_ktype = { 309 .release = damon_sysfs_target_release, 310 .sysfs_ops = &kobj_sysfs_ops, 311 .default_groups = damon_sysfs_target_groups, 312 }; 313 314 /* 315 * targets directory 316 */ 317 318 struct damon_sysfs_targets { 319 struct kobject kobj; 320 struct damon_sysfs_target **targets_arr; 321 int nr; 322 }; 323 324 static struct damon_sysfs_targets *damon_sysfs_targets_alloc(void) 325 { 326 return kzalloc_obj(struct damon_sysfs_targets); 327 } 328 329 static void damon_sysfs_targets_rm_dirs(struct damon_sysfs_targets *targets) 330 { 331 struct damon_sysfs_target **targets_arr = targets->targets_arr; 332 int i; 333 334 for (i = 0; i < targets->nr; i++) { 335 damon_sysfs_target_rm_dirs(targets_arr[i]); 336 kobject_put(&targets_arr[i]->kobj); 337 } 338 targets->nr = 0; 339 kfree(targets_arr); 340 targets->targets_arr = NULL; 341 } 342 343 static int damon_sysfs_targets_add_dirs(struct damon_sysfs_targets *targets, 344 int nr_targets) 345 { 346 struct damon_sysfs_target **targets_arr, *target; 347 int err, i; 348 349 damon_sysfs_targets_rm_dirs(targets); 350 if (!nr_targets) 351 return 0; 352 353 targets_arr = kmalloc_objs(*targets_arr, nr_targets, 354 GFP_KERNEL | __GFP_NOWARN); 355 if (!targets_arr) 356 return -ENOMEM; 357 targets->targets_arr = targets_arr; 358 359 for (i = 0; i < nr_targets; i++) { 360 target = damon_sysfs_target_alloc(); 361 if (!target) { 362 damon_sysfs_targets_rm_dirs(targets); 363 return -ENOMEM; 364 } 365 366 err = kobject_init_and_add(&target->kobj, 367 &damon_sysfs_target_ktype, &targets->kobj, 368 "%d", i); 369 if (err) 370 goto out; 371 372 err = damon_sysfs_target_add_dirs(target); 373 if (err) 374 goto out; 375 376 targets_arr[i] = target; 377 targets->nr++; 378 } 379 return 0; 380 381 out: 382 damon_sysfs_targets_rm_dirs(targets); 383 kobject_put(&target->kobj); 384 return err; 385 } 386 387 static ssize_t nr_targets_show(struct kobject *kobj, 388 struct kobj_attribute *attr, char *buf) 389 { 390 struct damon_sysfs_targets *targets = container_of(kobj, 391 struct damon_sysfs_targets, kobj); 392 393 return sysfs_emit(buf, "%d\n", targets->nr); 394 } 395 396 static ssize_t nr_targets_store(struct kobject *kobj, 397 struct kobj_attribute *attr, const char *buf, size_t count) 398 { 399 struct damon_sysfs_targets *targets; 400 int nr, err = kstrtoint(buf, 0, &nr); 401 402 if (err) 403 return err; 404 if (nr < 0) 405 return -EINVAL; 406 407 targets = container_of(kobj, struct damon_sysfs_targets, kobj); 408 409 if (!mutex_trylock(&damon_sysfs_lock)) 410 return -EBUSY; 411 err = damon_sysfs_targets_add_dirs(targets, nr); 412 mutex_unlock(&damon_sysfs_lock); 413 if (err) 414 return err; 415 416 return count; 417 } 418 419 static void damon_sysfs_targets_release(struct kobject *kobj) 420 { 421 kfree(container_of(kobj, struct damon_sysfs_targets, kobj)); 422 } 423 424 static struct kobj_attribute damon_sysfs_targets_nr_attr = 425 __ATTR_RW_MODE(nr_targets, 0600); 426 427 static struct attribute *damon_sysfs_targets_attrs[] = { 428 &damon_sysfs_targets_nr_attr.attr, 429 NULL, 430 }; 431 ATTRIBUTE_GROUPS(damon_sysfs_targets); 432 433 static const struct kobj_type damon_sysfs_targets_ktype = { 434 .release = damon_sysfs_targets_release, 435 .sysfs_ops = &kobj_sysfs_ops, 436 .default_groups = damon_sysfs_targets_groups, 437 }; 438 439 /* 440 * intervals goal directory 441 */ 442 443 struct damon_sysfs_intervals_goal { 444 struct kobject kobj; 445 unsigned long access_bp; 446 unsigned long aggrs; 447 unsigned long min_sample_us; 448 unsigned long max_sample_us; 449 }; 450 451 static struct damon_sysfs_intervals_goal *damon_sysfs_intervals_goal_alloc( 452 unsigned long access_bp, unsigned long aggrs, 453 unsigned long min_sample_us, unsigned long max_sample_us) 454 { 455 struct damon_sysfs_intervals_goal *goal = kmalloc_obj(*goal); 456 457 if (!goal) 458 return NULL; 459 460 goal->kobj = (struct kobject){}; 461 goal->access_bp = access_bp; 462 goal->aggrs = aggrs; 463 goal->min_sample_us = min_sample_us; 464 goal->max_sample_us = max_sample_us; 465 return goal; 466 } 467 468 static ssize_t access_bp_show(struct kobject *kobj, 469 struct kobj_attribute *attr, char *buf) 470 { 471 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 472 struct damon_sysfs_intervals_goal, kobj); 473 474 return sysfs_emit(buf, "%lu\n", goal->access_bp); 475 } 476 477 static ssize_t access_bp_store(struct kobject *kobj, 478 struct kobj_attribute *attr, const char *buf, size_t count) 479 { 480 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 481 struct damon_sysfs_intervals_goal, kobj); 482 unsigned long nr; 483 int err = kstrtoul(buf, 0, &nr); 484 485 if (err) 486 return err; 487 488 goal->access_bp = nr; 489 return count; 490 } 491 492 static ssize_t aggrs_show(struct kobject *kobj, 493 struct kobj_attribute *attr, char *buf) 494 { 495 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 496 struct damon_sysfs_intervals_goal, kobj); 497 498 return sysfs_emit(buf, "%lu\n", goal->aggrs); 499 } 500 501 static ssize_t aggrs_store(struct kobject *kobj, 502 struct kobj_attribute *attr, const char *buf, size_t count) 503 { 504 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 505 struct damon_sysfs_intervals_goal, kobj); 506 unsigned long nr; 507 int err = kstrtoul(buf, 0, &nr); 508 509 if (err) 510 return err; 511 512 goal->aggrs = nr; 513 return count; 514 } 515 516 static ssize_t min_sample_us_show(struct kobject *kobj, 517 struct kobj_attribute *attr, char *buf) 518 { 519 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 520 struct damon_sysfs_intervals_goal, kobj); 521 522 return sysfs_emit(buf, "%lu\n", goal->min_sample_us); 523 } 524 525 static ssize_t min_sample_us_store(struct kobject *kobj, 526 struct kobj_attribute *attr, const char *buf, size_t count) 527 { 528 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 529 struct damon_sysfs_intervals_goal, kobj); 530 unsigned long nr; 531 int err = kstrtoul(buf, 0, &nr); 532 533 if (err) 534 return err; 535 536 goal->min_sample_us = nr; 537 return count; 538 } 539 540 static ssize_t max_sample_us_show(struct kobject *kobj, 541 struct kobj_attribute *attr, char *buf) 542 { 543 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 544 struct damon_sysfs_intervals_goal, kobj); 545 546 return sysfs_emit(buf, "%lu\n", goal->max_sample_us); 547 } 548 549 static ssize_t max_sample_us_store(struct kobject *kobj, 550 struct kobj_attribute *attr, const char *buf, size_t count) 551 { 552 struct damon_sysfs_intervals_goal *goal = container_of(kobj, 553 struct damon_sysfs_intervals_goal, kobj); 554 unsigned long nr; 555 int err = kstrtoul(buf, 0, &nr); 556 557 if (err) 558 return err; 559 560 goal->max_sample_us = nr; 561 return count; 562 } 563 564 static void damon_sysfs_intervals_goal_release(struct kobject *kobj) 565 { 566 kfree(container_of(kobj, struct damon_sysfs_intervals_goal, kobj)); 567 } 568 569 static struct kobj_attribute damon_sysfs_intervals_goal_access_bp_attr = 570 __ATTR_RW_MODE(access_bp, 0600); 571 572 static struct kobj_attribute damon_sysfs_intervals_goal_aggrs_attr = 573 __ATTR_RW_MODE(aggrs, 0600); 574 575 static struct kobj_attribute damon_sysfs_intervals_goal_min_sample_us_attr = 576 __ATTR_RW_MODE(min_sample_us, 0600); 577 578 static struct kobj_attribute damon_sysfs_intervals_goal_max_sample_us_attr = 579 __ATTR_RW_MODE(max_sample_us, 0600); 580 581 static struct attribute *damon_sysfs_intervals_goal_attrs[] = { 582 &damon_sysfs_intervals_goal_access_bp_attr.attr, 583 &damon_sysfs_intervals_goal_aggrs_attr.attr, 584 &damon_sysfs_intervals_goal_min_sample_us_attr.attr, 585 &damon_sysfs_intervals_goal_max_sample_us_attr.attr, 586 NULL, 587 }; 588 ATTRIBUTE_GROUPS(damon_sysfs_intervals_goal); 589 590 static const struct kobj_type damon_sysfs_intervals_goal_ktype = { 591 .release = damon_sysfs_intervals_goal_release, 592 .sysfs_ops = &kobj_sysfs_ops, 593 .default_groups = damon_sysfs_intervals_goal_groups, 594 }; 595 596 /* 597 * intervals directory 598 */ 599 600 struct damon_sysfs_intervals { 601 struct kobject kobj; 602 unsigned long sample_us; 603 unsigned long aggr_us; 604 unsigned long update_us; 605 struct damon_sysfs_intervals_goal *intervals_goal; 606 }; 607 608 static struct damon_sysfs_intervals *damon_sysfs_intervals_alloc( 609 unsigned long sample_us, unsigned long aggr_us, 610 unsigned long update_us) 611 { 612 struct damon_sysfs_intervals *intervals = kmalloc_obj(*intervals); 613 614 if (!intervals) 615 return NULL; 616 617 intervals->kobj = (struct kobject){}; 618 intervals->sample_us = sample_us; 619 intervals->aggr_us = aggr_us; 620 intervals->update_us = update_us; 621 return intervals; 622 } 623 624 static int damon_sysfs_intervals_add_dirs(struct damon_sysfs_intervals *intervals) 625 { 626 struct damon_sysfs_intervals_goal *goal; 627 int err; 628 629 goal = damon_sysfs_intervals_goal_alloc(0, 0, 0, 0); 630 if (!goal) 631 return -ENOMEM; 632 633 err = kobject_init_and_add(&goal->kobj, 634 &damon_sysfs_intervals_goal_ktype, &intervals->kobj, 635 "intervals_goal"); 636 if (err) { 637 kobject_put(&goal->kobj); 638 intervals->intervals_goal = NULL; 639 return err; 640 } 641 intervals->intervals_goal = goal; 642 return 0; 643 } 644 645 static void damon_sysfs_intervals_rm_dirs(struct damon_sysfs_intervals *intervals) 646 { 647 kobject_put(&intervals->intervals_goal->kobj); 648 } 649 650 static ssize_t sample_us_show(struct kobject *kobj, 651 struct kobj_attribute *attr, char *buf) 652 { 653 struct damon_sysfs_intervals *intervals = container_of(kobj, 654 struct damon_sysfs_intervals, kobj); 655 656 return sysfs_emit(buf, "%lu\n", intervals->sample_us); 657 } 658 659 static ssize_t sample_us_store(struct kobject *kobj, 660 struct kobj_attribute *attr, const char *buf, size_t count) 661 { 662 struct damon_sysfs_intervals *intervals = container_of(kobj, 663 struct damon_sysfs_intervals, kobj); 664 unsigned long us; 665 int err = kstrtoul(buf, 0, &us); 666 667 if (err) 668 return err; 669 670 intervals->sample_us = us; 671 return count; 672 } 673 674 static ssize_t aggr_us_show(struct kobject *kobj, struct kobj_attribute *attr, 675 char *buf) 676 { 677 struct damon_sysfs_intervals *intervals = container_of(kobj, 678 struct damon_sysfs_intervals, kobj); 679 680 return sysfs_emit(buf, "%lu\n", intervals->aggr_us); 681 } 682 683 static ssize_t aggr_us_store(struct kobject *kobj, struct kobj_attribute *attr, 684 const char *buf, size_t count) 685 { 686 struct damon_sysfs_intervals *intervals = container_of(kobj, 687 struct damon_sysfs_intervals, kobj); 688 unsigned long us; 689 int err = kstrtoul(buf, 0, &us); 690 691 if (err) 692 return err; 693 694 intervals->aggr_us = us; 695 return count; 696 } 697 698 static ssize_t update_us_show(struct kobject *kobj, 699 struct kobj_attribute *attr, char *buf) 700 { 701 struct damon_sysfs_intervals *intervals = container_of(kobj, 702 struct damon_sysfs_intervals, kobj); 703 704 return sysfs_emit(buf, "%lu\n", intervals->update_us); 705 } 706 707 static ssize_t update_us_store(struct kobject *kobj, 708 struct kobj_attribute *attr, const char *buf, size_t count) 709 { 710 struct damon_sysfs_intervals *intervals = container_of(kobj, 711 struct damon_sysfs_intervals, kobj); 712 unsigned long us; 713 int err = kstrtoul(buf, 0, &us); 714 715 if (err) 716 return err; 717 718 intervals->update_us = us; 719 return count; 720 } 721 722 static void damon_sysfs_intervals_release(struct kobject *kobj) 723 { 724 kfree(container_of(kobj, struct damon_sysfs_intervals, kobj)); 725 } 726 727 static struct kobj_attribute damon_sysfs_intervals_sample_us_attr = 728 __ATTR_RW_MODE(sample_us, 0600); 729 730 static struct kobj_attribute damon_sysfs_intervals_aggr_us_attr = 731 __ATTR_RW_MODE(aggr_us, 0600); 732 733 static struct kobj_attribute damon_sysfs_intervals_update_us_attr = 734 __ATTR_RW_MODE(update_us, 0600); 735 736 static struct attribute *damon_sysfs_intervals_attrs[] = { 737 &damon_sysfs_intervals_sample_us_attr.attr, 738 &damon_sysfs_intervals_aggr_us_attr.attr, 739 &damon_sysfs_intervals_update_us_attr.attr, 740 NULL, 741 }; 742 ATTRIBUTE_GROUPS(damon_sysfs_intervals); 743 744 static const struct kobj_type damon_sysfs_intervals_ktype = { 745 .release = damon_sysfs_intervals_release, 746 .sysfs_ops = &kobj_sysfs_ops, 747 .default_groups = damon_sysfs_intervals_groups, 748 }; 749 750 /* 751 * monitoring_attrs directory 752 */ 753 754 struct damon_sysfs_attrs { 755 struct kobject kobj; 756 struct damon_sysfs_intervals *intervals; 757 struct damon_sysfs_ul_range *nr_regions_range; 758 }; 759 760 static struct damon_sysfs_attrs *damon_sysfs_attrs_alloc(void) 761 { 762 struct damon_sysfs_attrs *attrs = kmalloc_obj(*attrs); 763 764 if (!attrs) 765 return NULL; 766 attrs->kobj = (struct kobject){}; 767 return attrs; 768 } 769 770 static int damon_sysfs_attrs_add_dirs(struct damon_sysfs_attrs *attrs) 771 { 772 struct damon_sysfs_intervals *intervals; 773 struct damon_sysfs_ul_range *nr_regions_range; 774 int err; 775 776 intervals = damon_sysfs_intervals_alloc(5000, 100000, 60000000); 777 if (!intervals) 778 return -ENOMEM; 779 780 err = kobject_init_and_add(&intervals->kobj, 781 &damon_sysfs_intervals_ktype, &attrs->kobj, 782 "intervals"); 783 if (err) 784 goto put_intervals_out; 785 err = damon_sysfs_intervals_add_dirs(intervals); 786 if (err) 787 goto put_intervals_out; 788 attrs->intervals = intervals; 789 790 nr_regions_range = damon_sysfs_ul_range_alloc(10, 1000); 791 if (!nr_regions_range) { 792 err = -ENOMEM; 793 goto rmdir_put_intervals_out; 794 } 795 796 err = kobject_init_and_add(&nr_regions_range->kobj, 797 &damon_sysfs_ul_range_ktype, &attrs->kobj, 798 "nr_regions"); 799 if (err) 800 goto put_nr_regions_intervals_out; 801 attrs->nr_regions_range = nr_regions_range; 802 return 0; 803 804 put_nr_regions_intervals_out: 805 kobject_put(&nr_regions_range->kobj); 806 attrs->nr_regions_range = NULL; 807 rmdir_put_intervals_out: 808 damon_sysfs_intervals_rm_dirs(intervals); 809 put_intervals_out: 810 kobject_put(&intervals->kobj); 811 attrs->intervals = NULL; 812 return err; 813 } 814 815 static void damon_sysfs_attrs_rm_dirs(struct damon_sysfs_attrs *attrs) 816 { 817 kobject_put(&attrs->nr_regions_range->kobj); 818 damon_sysfs_intervals_rm_dirs(attrs->intervals); 819 kobject_put(&attrs->intervals->kobj); 820 } 821 822 static void damon_sysfs_attrs_release(struct kobject *kobj) 823 { 824 kfree(container_of(kobj, struct damon_sysfs_attrs, kobj)); 825 } 826 827 static struct attribute *damon_sysfs_attrs_attrs[] = { 828 NULL, 829 }; 830 ATTRIBUTE_GROUPS(damon_sysfs_attrs); 831 832 static const struct kobj_type damon_sysfs_attrs_ktype = { 833 .release = damon_sysfs_attrs_release, 834 .sysfs_ops = &kobj_sysfs_ops, 835 .default_groups = damon_sysfs_attrs_groups, 836 }; 837 838 /* 839 * context directory 840 */ 841 842 struct damon_sysfs_ops_name { 843 enum damon_ops_id ops_id; 844 char *name; 845 }; 846 847 static const struct damon_sysfs_ops_name damon_sysfs_ops_names[] = { 848 { 849 .ops_id = DAMON_OPS_VADDR, 850 .name = "vaddr", 851 }, 852 { 853 .ops_id = DAMON_OPS_FVADDR, 854 .name = "fvaddr", 855 }, 856 { 857 .ops_id = DAMON_OPS_PADDR, 858 .name = "paddr", 859 }, 860 }; 861 862 struct damon_sysfs_context { 863 struct kobject kobj; 864 enum damon_ops_id ops_id; 865 unsigned long addr_unit; 866 struct damon_sysfs_attrs *attrs; 867 struct damon_sysfs_targets *targets; 868 struct damon_sysfs_schemes *schemes; 869 }; 870 871 static struct damon_sysfs_context *damon_sysfs_context_alloc( 872 enum damon_ops_id ops_id) 873 { 874 struct damon_sysfs_context *context = kmalloc_obj(*context); 875 876 if (!context) 877 return NULL; 878 context->kobj = (struct kobject){}; 879 context->ops_id = ops_id; 880 context->addr_unit = 1; 881 return context; 882 } 883 884 static int damon_sysfs_context_set_attrs(struct damon_sysfs_context *context) 885 { 886 struct damon_sysfs_attrs *attrs = damon_sysfs_attrs_alloc(); 887 int err; 888 889 if (!attrs) 890 return -ENOMEM; 891 err = kobject_init_and_add(&attrs->kobj, &damon_sysfs_attrs_ktype, 892 &context->kobj, "monitoring_attrs"); 893 if (err) 894 goto out; 895 err = damon_sysfs_attrs_add_dirs(attrs); 896 if (err) 897 goto out; 898 context->attrs = attrs; 899 return 0; 900 901 out: 902 kobject_put(&attrs->kobj); 903 return err; 904 } 905 906 static int damon_sysfs_context_set_targets(struct damon_sysfs_context *context) 907 { 908 struct damon_sysfs_targets *targets = damon_sysfs_targets_alloc(); 909 int err; 910 911 if (!targets) 912 return -ENOMEM; 913 err = kobject_init_and_add(&targets->kobj, &damon_sysfs_targets_ktype, 914 &context->kobj, "targets"); 915 if (err) { 916 kobject_put(&targets->kobj); 917 return err; 918 } 919 context->targets = targets; 920 return 0; 921 } 922 923 static int damon_sysfs_context_set_schemes(struct damon_sysfs_context *context) 924 { 925 struct damon_sysfs_schemes *schemes = damon_sysfs_schemes_alloc(); 926 int err; 927 928 if (!schemes) 929 return -ENOMEM; 930 err = kobject_init_and_add(&schemes->kobj, &damon_sysfs_schemes_ktype, 931 &context->kobj, "schemes"); 932 if (err) { 933 kobject_put(&schemes->kobj); 934 return err; 935 } 936 context->schemes = schemes; 937 return 0; 938 } 939 940 static int damon_sysfs_context_add_dirs(struct damon_sysfs_context *context) 941 { 942 int err; 943 944 err = damon_sysfs_context_set_attrs(context); 945 if (err) 946 return err; 947 948 err = damon_sysfs_context_set_targets(context); 949 if (err) 950 goto rmdir_put_attrs_out; 951 952 err = damon_sysfs_context_set_schemes(context); 953 if (err) 954 goto put_targets_attrs_out; 955 return 0; 956 957 put_targets_attrs_out: 958 kobject_put(&context->targets->kobj); 959 context->targets = NULL; 960 rmdir_put_attrs_out: 961 damon_sysfs_attrs_rm_dirs(context->attrs); 962 kobject_put(&context->attrs->kobj); 963 context->attrs = NULL; 964 return err; 965 } 966 967 static void damon_sysfs_context_rm_dirs(struct damon_sysfs_context *context) 968 { 969 damon_sysfs_attrs_rm_dirs(context->attrs); 970 kobject_put(&context->attrs->kobj); 971 damon_sysfs_targets_rm_dirs(context->targets); 972 kobject_put(&context->targets->kobj); 973 damon_sysfs_schemes_rm_dirs(context->schemes); 974 kobject_put(&context->schemes->kobj); 975 } 976 977 static ssize_t avail_operations_show(struct kobject *kobj, 978 struct kobj_attribute *attr, char *buf) 979 { 980 int len = 0; 981 int i; 982 983 for (i = 0; i < ARRAY_SIZE(damon_sysfs_ops_names); i++) { 984 const struct damon_sysfs_ops_name *ops_name; 985 986 ops_name = &damon_sysfs_ops_names[i]; 987 if (!damon_is_registered_ops(ops_name->ops_id)) 988 continue; 989 len += sysfs_emit_at(buf, len, "%s\n", ops_name->name); 990 } 991 return len; 992 } 993 994 static ssize_t operations_show(struct kobject *kobj, 995 struct kobj_attribute *attr, char *buf) 996 { 997 struct damon_sysfs_context *context = container_of(kobj, 998 struct damon_sysfs_context, kobj); 999 int i; 1000 1001 for (i = 0; i < ARRAY_SIZE(damon_sysfs_ops_names); i++) { 1002 const struct damon_sysfs_ops_name *ops_name; 1003 1004 ops_name = &damon_sysfs_ops_names[i]; 1005 if (ops_name->ops_id == context->ops_id) 1006 return sysfs_emit(buf, "%s\n", ops_name->name); 1007 } 1008 return -EINVAL; 1009 } 1010 1011 static ssize_t operations_store(struct kobject *kobj, 1012 struct kobj_attribute *attr, const char *buf, size_t count) 1013 { 1014 struct damon_sysfs_context *context = container_of(kobj, 1015 struct damon_sysfs_context, kobj); 1016 int i; 1017 1018 for (i = 0; i < ARRAY_SIZE(damon_sysfs_ops_names); i++) { 1019 const struct damon_sysfs_ops_name *ops_name; 1020 1021 ops_name = &damon_sysfs_ops_names[i]; 1022 if (sysfs_streq(buf, ops_name->name)) { 1023 context->ops_id = ops_name->ops_id; 1024 return count; 1025 } 1026 } 1027 return -EINVAL; 1028 } 1029 1030 static ssize_t addr_unit_show(struct kobject *kobj, 1031 struct kobj_attribute *attr, char *buf) 1032 { 1033 struct damon_sysfs_context *context = container_of(kobj, 1034 struct damon_sysfs_context, kobj); 1035 1036 return sysfs_emit(buf, "%lu\n", context->addr_unit); 1037 } 1038 1039 static ssize_t addr_unit_store(struct kobject *kobj, 1040 struct kobj_attribute *attr, const char *buf, size_t count) 1041 { 1042 struct damon_sysfs_context *context = container_of(kobj, 1043 struct damon_sysfs_context, kobj); 1044 unsigned long input_addr_unit; 1045 int err = kstrtoul(buf, 0, &input_addr_unit); 1046 1047 if (err) 1048 return err; 1049 if (!input_addr_unit) 1050 return -EINVAL; 1051 1052 context->addr_unit = input_addr_unit; 1053 return count; 1054 } 1055 1056 static void damon_sysfs_context_release(struct kobject *kobj) 1057 { 1058 kfree(container_of(kobj, struct damon_sysfs_context, kobj)); 1059 } 1060 1061 static struct kobj_attribute damon_sysfs_context_avail_operations_attr = 1062 __ATTR_RO_MODE(avail_operations, 0400); 1063 1064 static struct kobj_attribute damon_sysfs_context_operations_attr = 1065 __ATTR_RW_MODE(operations, 0600); 1066 1067 static struct kobj_attribute damon_sysfs_context_addr_unit_attr = 1068 __ATTR_RW_MODE(addr_unit, 0600); 1069 1070 static struct attribute *damon_sysfs_context_attrs[] = { 1071 &damon_sysfs_context_avail_operations_attr.attr, 1072 &damon_sysfs_context_operations_attr.attr, 1073 &damon_sysfs_context_addr_unit_attr.attr, 1074 NULL, 1075 }; 1076 ATTRIBUTE_GROUPS(damon_sysfs_context); 1077 1078 static const struct kobj_type damon_sysfs_context_ktype = { 1079 .release = damon_sysfs_context_release, 1080 .sysfs_ops = &kobj_sysfs_ops, 1081 .default_groups = damon_sysfs_context_groups, 1082 }; 1083 1084 /* 1085 * contexts directory 1086 */ 1087 1088 struct damon_sysfs_contexts { 1089 struct kobject kobj; 1090 struct damon_sysfs_context **contexts_arr; 1091 int nr; 1092 }; 1093 1094 static struct damon_sysfs_contexts *damon_sysfs_contexts_alloc(void) 1095 { 1096 return kzalloc_obj(struct damon_sysfs_contexts); 1097 } 1098 1099 static void damon_sysfs_contexts_rm_dirs(struct damon_sysfs_contexts *contexts) 1100 { 1101 struct damon_sysfs_context **contexts_arr = contexts->contexts_arr; 1102 int i; 1103 1104 for (i = 0; i < contexts->nr; i++) { 1105 damon_sysfs_context_rm_dirs(contexts_arr[i]); 1106 kobject_put(&contexts_arr[i]->kobj); 1107 } 1108 contexts->nr = 0; 1109 kfree(contexts_arr); 1110 contexts->contexts_arr = NULL; 1111 } 1112 1113 static int damon_sysfs_contexts_add_dirs(struct damon_sysfs_contexts *contexts, 1114 int nr_contexts) 1115 { 1116 struct damon_sysfs_context **contexts_arr, *context; 1117 int err, i; 1118 1119 damon_sysfs_contexts_rm_dirs(contexts); 1120 if (!nr_contexts) 1121 return 0; 1122 1123 contexts_arr = kmalloc_objs(*contexts_arr, nr_contexts, 1124 GFP_KERNEL | __GFP_NOWARN); 1125 if (!contexts_arr) 1126 return -ENOMEM; 1127 contexts->contexts_arr = contexts_arr; 1128 1129 for (i = 0; i < nr_contexts; i++) { 1130 context = damon_sysfs_context_alloc(DAMON_OPS_VADDR); 1131 if (!context) { 1132 damon_sysfs_contexts_rm_dirs(contexts); 1133 return -ENOMEM; 1134 } 1135 1136 err = kobject_init_and_add(&context->kobj, 1137 &damon_sysfs_context_ktype, &contexts->kobj, 1138 "%d", i); 1139 if (err) 1140 goto out; 1141 1142 err = damon_sysfs_context_add_dirs(context); 1143 if (err) 1144 goto out; 1145 1146 contexts_arr[i] = context; 1147 contexts->nr++; 1148 } 1149 return 0; 1150 1151 out: 1152 damon_sysfs_contexts_rm_dirs(contexts); 1153 kobject_put(&context->kobj); 1154 return err; 1155 } 1156 1157 static ssize_t nr_contexts_show(struct kobject *kobj, 1158 struct kobj_attribute *attr, char *buf) 1159 { 1160 struct damon_sysfs_contexts *contexts = container_of(kobj, 1161 struct damon_sysfs_contexts, kobj); 1162 1163 return sysfs_emit(buf, "%d\n", contexts->nr); 1164 } 1165 1166 static ssize_t nr_contexts_store(struct kobject *kobj, 1167 struct kobj_attribute *attr, const char *buf, size_t count) 1168 { 1169 struct damon_sysfs_contexts *contexts; 1170 int nr, err; 1171 1172 err = kstrtoint(buf, 0, &nr); 1173 if (err) 1174 return err; 1175 /* TODO: support multiple contexts per kdamond */ 1176 if (nr < 0 || 1 < nr) 1177 return -EINVAL; 1178 1179 contexts = container_of(kobj, struct damon_sysfs_contexts, kobj); 1180 if (!mutex_trylock(&damon_sysfs_lock)) 1181 return -EBUSY; 1182 err = damon_sysfs_contexts_add_dirs(contexts, nr); 1183 mutex_unlock(&damon_sysfs_lock); 1184 if (err) 1185 return err; 1186 1187 return count; 1188 } 1189 1190 static void damon_sysfs_contexts_release(struct kobject *kobj) 1191 { 1192 kfree(container_of(kobj, struct damon_sysfs_contexts, kobj)); 1193 } 1194 1195 static struct kobj_attribute damon_sysfs_contexts_nr_attr 1196 = __ATTR_RW_MODE(nr_contexts, 0600); 1197 1198 static struct attribute *damon_sysfs_contexts_attrs[] = { 1199 &damon_sysfs_contexts_nr_attr.attr, 1200 NULL, 1201 }; 1202 ATTRIBUTE_GROUPS(damon_sysfs_contexts); 1203 1204 static const struct kobj_type damon_sysfs_contexts_ktype = { 1205 .release = damon_sysfs_contexts_release, 1206 .sysfs_ops = &kobj_sysfs_ops, 1207 .default_groups = damon_sysfs_contexts_groups, 1208 }; 1209 1210 /* 1211 * kdamond directory 1212 */ 1213 1214 struct damon_sysfs_kdamond { 1215 struct kobject kobj; 1216 struct damon_sysfs_contexts *contexts; 1217 struct damon_ctx *damon_ctx; 1218 unsigned int refresh_ms; 1219 }; 1220 1221 static struct damon_sysfs_kdamond *damon_sysfs_kdamond_alloc(void) 1222 { 1223 return kzalloc_obj(struct damon_sysfs_kdamond); 1224 } 1225 1226 static int damon_sysfs_kdamond_add_dirs(struct damon_sysfs_kdamond *kdamond) 1227 { 1228 struct damon_sysfs_contexts *contexts; 1229 int err; 1230 1231 contexts = damon_sysfs_contexts_alloc(); 1232 if (!contexts) 1233 return -ENOMEM; 1234 1235 err = kobject_init_and_add(&contexts->kobj, 1236 &damon_sysfs_contexts_ktype, &kdamond->kobj, 1237 "contexts"); 1238 if (err) { 1239 kobject_put(&contexts->kobj); 1240 return err; 1241 } 1242 kdamond->contexts = contexts; 1243 1244 return err; 1245 } 1246 1247 static void damon_sysfs_kdamond_rm_dirs(struct damon_sysfs_kdamond *kdamond) 1248 { 1249 damon_sysfs_contexts_rm_dirs(kdamond->contexts); 1250 kobject_put(&kdamond->contexts->kobj); 1251 } 1252 1253 /* 1254 * enum damon_sysfs_cmd - Commands for a specific kdamond. 1255 */ 1256 enum damon_sysfs_cmd { 1257 /* @DAMON_SYSFS_CMD_ON: Turn the kdamond on. */ 1258 DAMON_SYSFS_CMD_ON, 1259 /* @DAMON_SYSFS_CMD_OFF: Turn the kdamond off. */ 1260 DAMON_SYSFS_CMD_OFF, 1261 /* @DAMON_SYSFS_CMD_COMMIT: Update kdamond inputs. */ 1262 DAMON_SYSFS_CMD_COMMIT, 1263 /* 1264 * @DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS: Commit the quota goals 1265 * to DAMON. 1266 */ 1267 DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS, 1268 /* 1269 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS: Update scheme stats sysfs 1270 * files. 1271 */ 1272 DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS, 1273 /* 1274 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES: Update 1275 * tried_regions/total_bytes sysfs files for each scheme. 1276 */ 1277 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES, 1278 /* 1279 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS: Update schemes tried 1280 * regions 1281 */ 1282 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS, 1283 /* 1284 * @DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS: Clear schemes tried 1285 * regions 1286 */ 1287 DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS, 1288 /* 1289 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS: Update the 1290 * effective size quota of the scheme in bytes. 1291 */ 1292 DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS, 1293 /* 1294 * @DAMON_SYSFS_CMD_UPDATE_TUNED_INTERVALS: Update the tuned monitoring 1295 * intervals. 1296 */ 1297 DAMON_SYSFS_CMD_UPDATE_TUNED_INTERVALS, 1298 /* 1299 * @NR_DAMON_SYSFS_CMDS: Total number of DAMON sysfs commands. 1300 */ 1301 NR_DAMON_SYSFS_CMDS, 1302 }; 1303 1304 /* Should match with enum damon_sysfs_cmd */ 1305 static const char * const damon_sysfs_cmd_strs[] = { 1306 "on", 1307 "off", 1308 "commit", 1309 "commit_schemes_quota_goals", 1310 "update_schemes_stats", 1311 "update_schemes_tried_bytes", 1312 "update_schemes_tried_regions", 1313 "clear_schemes_tried_regions", 1314 "update_schemes_effective_quotas", 1315 "update_tuned_intervals", 1316 }; 1317 1318 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr, 1319 char *buf) 1320 { 1321 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1322 struct damon_sysfs_kdamond, kobj); 1323 struct damon_ctx *ctx; 1324 bool running = false; 1325 1326 if (!mutex_trylock(&damon_sysfs_lock)) 1327 return -EBUSY; 1328 1329 ctx = kdamond->damon_ctx; 1330 if (ctx) 1331 running = damon_is_running(ctx); 1332 1333 mutex_unlock(&damon_sysfs_lock); 1334 1335 return sysfs_emit(buf, "%s\n", running ? 1336 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_ON] : 1337 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_OFF]); 1338 } 1339 1340 static int damon_sysfs_set_attrs(struct damon_ctx *ctx, 1341 struct damon_sysfs_attrs *sys_attrs) 1342 { 1343 struct damon_sysfs_intervals *sys_intervals = sys_attrs->intervals; 1344 struct damon_sysfs_intervals_goal *sys_goal = 1345 sys_intervals->intervals_goal; 1346 struct damon_sysfs_ul_range *sys_nr_regions = 1347 sys_attrs->nr_regions_range; 1348 struct damon_attrs attrs = { 1349 .sample_interval = sys_intervals->sample_us, 1350 .aggr_interval = sys_intervals->aggr_us, 1351 .intervals_goal = { 1352 .access_bp = sys_goal->access_bp, 1353 .aggrs = sys_goal->aggrs, 1354 .min_sample_us = sys_goal->min_sample_us, 1355 .max_sample_us = sys_goal->max_sample_us}, 1356 .ops_update_interval = sys_intervals->update_us, 1357 .min_nr_regions = sys_nr_regions->min, 1358 .max_nr_regions = sys_nr_regions->max, 1359 }; 1360 return damon_set_attrs(ctx, &attrs); 1361 } 1362 1363 static int damon_sysfs_set_regions(struct damon_target *t, 1364 struct damon_sysfs_regions *sysfs_regions, 1365 unsigned long min_region_sz) 1366 { 1367 struct damon_addr_range *ranges = kmalloc_objs(*ranges, 1368 sysfs_regions->nr, 1369 GFP_KERNEL | __GFP_NOWARN); 1370 int i, err = -EINVAL; 1371 1372 if (!ranges) 1373 return -ENOMEM; 1374 for (i = 0; i < sysfs_regions->nr; i++) { 1375 struct damon_sysfs_region *sys_region = 1376 sysfs_regions->regions_arr[i]; 1377 1378 if (sys_region->ar.start > sys_region->ar.end) 1379 goto out; 1380 1381 ranges[i].start = sys_region->ar.start; 1382 ranges[i].end = sys_region->ar.end; 1383 if (i == 0) 1384 continue; 1385 if (ranges[i - 1].end > ranges[i].start) 1386 goto out; 1387 } 1388 err = damon_set_regions(t, ranges, sysfs_regions->nr, min_region_sz); 1389 out: 1390 kfree(ranges); 1391 return err; 1392 1393 } 1394 1395 static int damon_sysfs_add_target(struct damon_sysfs_target *sys_target, 1396 struct damon_ctx *ctx) 1397 { 1398 struct damon_target *t = damon_new_target(); 1399 1400 if (!t) 1401 return -ENOMEM; 1402 damon_add_target(ctx, t); 1403 if (damon_target_has_pid(ctx)) { 1404 t->pid = find_get_pid(sys_target->pid); 1405 if (!t->pid) 1406 /* caller will destroy targets */ 1407 return -EINVAL; 1408 } 1409 t->obsolete = sys_target->obsolete; 1410 return damon_sysfs_set_regions(t, sys_target->regions, 1411 ctx->min_region_sz); 1412 } 1413 1414 static int damon_sysfs_add_targets(struct damon_ctx *ctx, 1415 struct damon_sysfs_targets *sysfs_targets) 1416 { 1417 int i, err; 1418 1419 /* Multiple physical address space monitoring targets makes no sense */ 1420 if (ctx->ops.id == DAMON_OPS_PADDR && sysfs_targets->nr > 1) 1421 return -EINVAL; 1422 1423 for (i = 0; i < sysfs_targets->nr; i++) { 1424 struct damon_sysfs_target *st = sysfs_targets->targets_arr[i]; 1425 1426 err = damon_sysfs_add_target(st, ctx); 1427 if (err) 1428 return err; 1429 } 1430 return 0; 1431 } 1432 1433 /* 1434 * damon_sysfs_upd_schemes_stats() - Update schemes stats sysfs files. 1435 * @data: The kobject wrapper that associated to the kdamond thread. 1436 * 1437 * This function reads the schemes stats of specific kdamond and update the 1438 * related values for sysfs files. This function should be called from DAMON 1439 * worker thread,to safely access the DAMON contexts-internal data. Caller 1440 * should also ensure holding ``damon_syfs_lock``, and ->damon_ctx of @data is 1441 * not NULL but a valid pointer, to safely access DAMON sysfs variables. 1442 */ 1443 static int damon_sysfs_upd_schemes_stats(void *data) 1444 { 1445 struct damon_sysfs_kdamond *kdamond = data; 1446 struct damon_ctx *ctx = kdamond->damon_ctx; 1447 1448 damon_sysfs_schemes_update_stats( 1449 kdamond->contexts->contexts_arr[0]->schemes, ctx); 1450 return 0; 1451 } 1452 1453 static inline bool damon_sysfs_kdamond_running( 1454 struct damon_sysfs_kdamond *kdamond) 1455 { 1456 return kdamond->damon_ctx && 1457 damon_is_running(kdamond->damon_ctx); 1458 } 1459 1460 static int damon_sysfs_apply_inputs(struct damon_ctx *ctx, 1461 struct damon_sysfs_context *sys_ctx) 1462 { 1463 int err; 1464 1465 err = damon_select_ops(ctx, sys_ctx->ops_id); 1466 if (err) 1467 return err; 1468 ctx->addr_unit = sys_ctx->addr_unit; 1469 /* addr_unit is respected by only DAMON_OPS_PADDR */ 1470 if (sys_ctx->ops_id == DAMON_OPS_PADDR) 1471 ctx->min_region_sz = max( 1472 DAMON_MIN_REGION_SZ / sys_ctx->addr_unit, 1); 1473 err = damon_sysfs_set_attrs(ctx, sys_ctx->attrs); 1474 if (err) 1475 return err; 1476 err = damon_sysfs_add_targets(ctx, sys_ctx->targets); 1477 if (err) 1478 return err; 1479 return damon_sysfs_add_schemes(ctx, sys_ctx->schemes); 1480 } 1481 1482 static struct damon_ctx *damon_sysfs_build_ctx( 1483 struct damon_sysfs_context *sys_ctx); 1484 1485 /* 1486 * Return a new damon_ctx for testing new parameters to commit. 1487 */ 1488 static struct damon_ctx *damon_sysfs_new_test_ctx( 1489 struct damon_ctx *running_ctx) 1490 { 1491 struct damon_ctx *test_ctx; 1492 int err; 1493 1494 test_ctx = damon_new_ctx(); 1495 if (!test_ctx) 1496 return NULL; 1497 err = damon_commit_ctx(test_ctx, running_ctx); 1498 if (err) { 1499 damon_destroy_ctx(test_ctx); 1500 return NULL; 1501 } 1502 return test_ctx; 1503 } 1504 1505 /* 1506 * damon_sysfs_commit_input() - Commit user inputs to a running kdamond. 1507 * @kdamond: The kobject wrapper for the associated kdamond. 1508 * 1509 * Returns error if the sysfs input is wrong. 1510 */ 1511 static int damon_sysfs_commit_input(void *data) 1512 { 1513 struct damon_sysfs_kdamond *kdamond = data; 1514 struct damon_ctx *param_ctx, *test_ctx; 1515 int err; 1516 1517 if (!damon_sysfs_kdamond_running(kdamond)) 1518 return -EINVAL; 1519 /* TODO: Support multiple contexts per kdamond */ 1520 if (kdamond->contexts->nr != 1) 1521 return -EINVAL; 1522 1523 param_ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]); 1524 if (IS_ERR(param_ctx)) 1525 return PTR_ERR(param_ctx); 1526 test_ctx = damon_sysfs_new_test_ctx(kdamond->damon_ctx); 1527 if (!test_ctx) 1528 return -ENOMEM; 1529 err = damon_commit_ctx(test_ctx, param_ctx); 1530 if (err) 1531 goto out; 1532 err = damon_commit_ctx(kdamond->damon_ctx, param_ctx); 1533 out: 1534 damon_destroy_ctx(test_ctx); 1535 damon_destroy_ctx(param_ctx); 1536 return err; 1537 } 1538 1539 static int damon_sysfs_commit_schemes_quota_goals(void *data) 1540 { 1541 struct damon_sysfs_kdamond *sysfs_kdamond = data; 1542 struct damon_ctx *ctx; 1543 struct damon_sysfs_context *sysfs_ctx; 1544 1545 if (!damon_sysfs_kdamond_running(sysfs_kdamond)) 1546 return -EINVAL; 1547 /* TODO: Support multiple contexts per kdamond */ 1548 if (sysfs_kdamond->contexts->nr != 1) 1549 return -EINVAL; 1550 1551 ctx = sysfs_kdamond->damon_ctx; 1552 sysfs_ctx = sysfs_kdamond->contexts->contexts_arr[0]; 1553 return damos_sysfs_set_quota_scores(sysfs_ctx->schemes, ctx); 1554 } 1555 1556 /* 1557 * damon_sysfs_upd_schemes_effective_quotas() - Update schemes effective quotas 1558 * sysfs files. 1559 * @data: The kobject wrapper that associated to the kdamond thread. 1560 * 1561 * This function reads the schemes' effective quotas of specific kdamond and 1562 * update the related values for sysfs files. This function should be called 1563 * from DAMON callbacks while holding ``damon_syfs_lock``, to safely access the 1564 * DAMON contexts-internal data and DAMON sysfs variables. 1565 */ 1566 static int damon_sysfs_upd_schemes_effective_quotas(void *data) 1567 { 1568 struct damon_sysfs_kdamond *kdamond = data; 1569 struct damon_ctx *ctx = kdamond->damon_ctx; 1570 1571 damos_sysfs_update_effective_quotas( 1572 kdamond->contexts->contexts_arr[0]->schemes, ctx); 1573 return 0; 1574 } 1575 1576 static int damon_sysfs_upd_tuned_intervals(void *data) 1577 { 1578 struct damon_sysfs_kdamond *kdamond = data; 1579 struct damon_ctx *ctx = kdamond->damon_ctx; 1580 1581 kdamond->contexts->contexts_arr[0]->attrs->intervals->sample_us = 1582 ctx->attrs.sample_interval; 1583 kdamond->contexts->contexts_arr[0]->attrs->intervals->aggr_us = 1584 ctx->attrs.aggr_interval; 1585 return 0; 1586 } 1587 1588 static struct damon_ctx *damon_sysfs_build_ctx( 1589 struct damon_sysfs_context *sys_ctx) 1590 { 1591 struct damon_ctx *ctx = damon_new_ctx(); 1592 int err; 1593 1594 if (!ctx) 1595 return ERR_PTR(-ENOMEM); 1596 1597 err = damon_sysfs_apply_inputs(ctx, sys_ctx); 1598 if (err) { 1599 damon_destroy_ctx(ctx); 1600 return ERR_PTR(err); 1601 } 1602 1603 return ctx; 1604 } 1605 1606 static unsigned long damon_sysfs_next_update_jiffies; 1607 1608 static int damon_sysfs_repeat_call_fn(void *data) 1609 { 1610 struct damon_sysfs_kdamond *sysfs_kdamond = data; 1611 1612 if (!sysfs_kdamond->refresh_ms) 1613 return 0; 1614 if (time_before(jiffies, damon_sysfs_next_update_jiffies)) 1615 return 0; 1616 damon_sysfs_next_update_jiffies = jiffies + 1617 msecs_to_jiffies(sysfs_kdamond->refresh_ms); 1618 1619 if (!mutex_trylock(&damon_sysfs_lock)) 1620 return 0; 1621 damon_sysfs_upd_tuned_intervals(sysfs_kdamond); 1622 damon_sysfs_upd_schemes_stats(sysfs_kdamond); 1623 damon_sysfs_upd_schemes_effective_quotas(sysfs_kdamond); 1624 mutex_unlock(&damon_sysfs_lock); 1625 return 0; 1626 } 1627 1628 static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond) 1629 { 1630 struct damon_ctx *ctx; 1631 struct damon_call_control *repeat_call_control; 1632 int err; 1633 1634 if (damon_sysfs_kdamond_running(kdamond)) 1635 return -EBUSY; 1636 /* TODO: support multiple contexts per kdamond */ 1637 if (kdamond->contexts->nr != 1) 1638 return -EINVAL; 1639 1640 if (kdamond->damon_ctx) 1641 damon_destroy_ctx(kdamond->damon_ctx); 1642 kdamond->damon_ctx = NULL; 1643 1644 repeat_call_control = kmalloc_obj(*repeat_call_control); 1645 if (!repeat_call_control) 1646 return -ENOMEM; 1647 1648 ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]); 1649 if (IS_ERR(ctx)) { 1650 kfree(repeat_call_control); 1651 return PTR_ERR(ctx); 1652 } 1653 err = damon_start(&ctx, 1, false); 1654 if (err) { 1655 kfree(repeat_call_control); 1656 damon_destroy_ctx(ctx); 1657 return err; 1658 } 1659 kdamond->damon_ctx = ctx; 1660 1661 damon_sysfs_next_update_jiffies = 1662 jiffies + msecs_to_jiffies(kdamond->refresh_ms); 1663 1664 repeat_call_control->fn = damon_sysfs_repeat_call_fn; 1665 repeat_call_control->data = kdamond; 1666 repeat_call_control->repeat = true; 1667 repeat_call_control->dealloc_on_cancel = true; 1668 damon_call(ctx, repeat_call_control); 1669 return err; 1670 } 1671 1672 static int damon_sysfs_turn_damon_off(struct damon_sysfs_kdamond *kdamond) 1673 { 1674 if (!kdamond->damon_ctx) 1675 return -EINVAL; 1676 return damon_stop(&kdamond->damon_ctx, 1); 1677 /* 1678 * To allow users show final monitoring results of already turned-off 1679 * DAMON, we free kdamond->damon_ctx in next 1680 * damon_sysfs_turn_damon_on(), or kdamonds_nr_store() 1681 */ 1682 } 1683 1684 static int damon_sysfs_damon_call(int (*fn)(void *data), 1685 struct damon_sysfs_kdamond *kdamond) 1686 { 1687 struct damon_call_control call_control = {}; 1688 int err; 1689 1690 if (!kdamond->damon_ctx) 1691 return -EINVAL; 1692 call_control.fn = fn; 1693 call_control.data = kdamond; 1694 err = damon_call(kdamond->damon_ctx, &call_control); 1695 return err ? err : call_control.return_code; 1696 } 1697 1698 struct damon_sysfs_schemes_walk_data { 1699 struct damon_sysfs_kdamond *sysfs_kdamond; 1700 bool total_bytes_only; 1701 }; 1702 1703 /* populate the region directory */ 1704 static void damon_sysfs_schemes_tried_regions_upd_one(void *data, struct damon_ctx *ctx, 1705 struct damon_target *t, struct damon_region *r, 1706 struct damos *s, unsigned long sz_filter_passed) 1707 { 1708 struct damon_sysfs_schemes_walk_data *walk_data = data; 1709 struct damon_sysfs_kdamond *sysfs_kdamond = walk_data->sysfs_kdamond; 1710 1711 damos_sysfs_populate_region_dir( 1712 sysfs_kdamond->contexts->contexts_arr[0]->schemes, 1713 ctx, t, r, s, walk_data->total_bytes_only, 1714 sz_filter_passed); 1715 } 1716 1717 static int damon_sysfs_update_schemes_tried_regions( 1718 struct damon_sysfs_kdamond *sysfs_kdamond, bool total_bytes_only) 1719 { 1720 struct damon_sysfs_schemes_walk_data walk_data = { 1721 .sysfs_kdamond = sysfs_kdamond, 1722 .total_bytes_only = total_bytes_only, 1723 }; 1724 struct damos_walk_control control = { 1725 .walk_fn = damon_sysfs_schemes_tried_regions_upd_one, 1726 .data = &walk_data, 1727 }; 1728 struct damon_ctx *ctx = sysfs_kdamond->damon_ctx; 1729 1730 if (!ctx) 1731 return -EINVAL; 1732 1733 damon_sysfs_schemes_clear_regions( 1734 sysfs_kdamond->contexts->contexts_arr[0]->schemes); 1735 return damos_walk(ctx, &control); 1736 } 1737 1738 /* 1739 * damon_sysfs_handle_cmd() - Handle a command for a specific kdamond. 1740 * @cmd: The command to handle. 1741 * @kdamond: The kobject wrapper for the associated kdamond. 1742 * 1743 * This function handles a DAMON sysfs command for a kdamond. 1744 * 1745 * Return: 0 on success, negative error code otherwise. 1746 */ 1747 static int damon_sysfs_handle_cmd(enum damon_sysfs_cmd cmd, 1748 struct damon_sysfs_kdamond *kdamond) 1749 { 1750 switch (cmd) { 1751 case DAMON_SYSFS_CMD_ON: 1752 return damon_sysfs_turn_damon_on(kdamond); 1753 case DAMON_SYSFS_CMD_OFF: 1754 return damon_sysfs_turn_damon_off(kdamond); 1755 case DAMON_SYSFS_CMD_COMMIT: 1756 return damon_sysfs_damon_call( 1757 damon_sysfs_commit_input, kdamond); 1758 case DAMON_SYSFS_CMD_COMMIT_SCHEMES_QUOTA_GOALS: 1759 return damon_sysfs_damon_call( 1760 damon_sysfs_commit_schemes_quota_goals, 1761 kdamond); 1762 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS: 1763 return damon_sysfs_damon_call( 1764 damon_sysfs_upd_schemes_stats, kdamond); 1765 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_BYTES: 1766 return damon_sysfs_update_schemes_tried_regions(kdamond, true); 1767 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS: 1768 return damon_sysfs_update_schemes_tried_regions(kdamond, false); 1769 case DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS: 1770 return damon_sysfs_schemes_clear_regions( 1771 kdamond->contexts->contexts_arr[0]->schemes); 1772 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_EFFECTIVE_QUOTAS: 1773 return damon_sysfs_damon_call( 1774 damon_sysfs_upd_schemes_effective_quotas, 1775 kdamond); 1776 case DAMON_SYSFS_CMD_UPDATE_TUNED_INTERVALS: 1777 return damon_sysfs_damon_call( 1778 damon_sysfs_upd_tuned_intervals, kdamond); 1779 default: 1780 return -EINVAL; 1781 } 1782 } 1783 1784 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr, 1785 const char *buf, size_t count) 1786 { 1787 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1788 struct damon_sysfs_kdamond, kobj); 1789 enum damon_sysfs_cmd cmd; 1790 ssize_t ret = -EINVAL; 1791 1792 if (!mutex_trylock(&damon_sysfs_lock)) 1793 return -EBUSY; 1794 for (cmd = 0; cmd < NR_DAMON_SYSFS_CMDS; cmd++) { 1795 if (sysfs_streq(buf, damon_sysfs_cmd_strs[cmd])) { 1796 ret = damon_sysfs_handle_cmd(cmd, kdamond); 1797 break; 1798 } 1799 } 1800 mutex_unlock(&damon_sysfs_lock); 1801 if (!ret) 1802 ret = count; 1803 return ret; 1804 } 1805 1806 static ssize_t pid_show(struct kobject *kobj, 1807 struct kobj_attribute *attr, char *buf) 1808 { 1809 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1810 struct damon_sysfs_kdamond, kobj); 1811 struct damon_ctx *ctx; 1812 int pid = -1; 1813 1814 if (!mutex_trylock(&damon_sysfs_lock)) 1815 return -EBUSY; 1816 ctx = kdamond->damon_ctx; 1817 if (!ctx) 1818 goto out; 1819 1820 pid = damon_kdamond_pid(ctx); 1821 if (pid < 0) 1822 pid = -1; 1823 out: 1824 mutex_unlock(&damon_sysfs_lock); 1825 return sysfs_emit(buf, "%d\n", pid); 1826 } 1827 1828 static ssize_t refresh_ms_show(struct kobject *kobj, 1829 struct kobj_attribute *attr, char *buf) 1830 { 1831 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1832 struct damon_sysfs_kdamond, kobj); 1833 1834 return sysfs_emit(buf, "%u\n", kdamond->refresh_ms); 1835 } 1836 1837 static ssize_t refresh_ms_store(struct kobject *kobj, 1838 struct kobj_attribute *attr, const char *buf, size_t count) 1839 { 1840 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1841 struct damon_sysfs_kdamond, kobj); 1842 unsigned int nr; 1843 int err = kstrtouint(buf, 0, &nr); 1844 1845 if (err) 1846 return err; 1847 1848 kdamond->refresh_ms = nr; 1849 return count; 1850 } 1851 1852 static void damon_sysfs_kdamond_release(struct kobject *kobj) 1853 { 1854 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1855 struct damon_sysfs_kdamond, kobj); 1856 1857 if (kdamond->damon_ctx) 1858 damon_destroy_ctx(kdamond->damon_ctx); 1859 kfree(kdamond); 1860 } 1861 1862 static struct kobj_attribute damon_sysfs_kdamond_state_attr = 1863 __ATTR_RW_MODE(state, 0600); 1864 1865 static struct kobj_attribute damon_sysfs_kdamond_pid_attr = 1866 __ATTR_RO_MODE(pid, 0400); 1867 1868 static struct kobj_attribute damon_sysfs_kdamond_refresh_ms_attr = 1869 __ATTR_RW_MODE(refresh_ms, 0600); 1870 1871 static struct attribute *damon_sysfs_kdamond_attrs[] = { 1872 &damon_sysfs_kdamond_state_attr.attr, 1873 &damon_sysfs_kdamond_pid_attr.attr, 1874 &damon_sysfs_kdamond_refresh_ms_attr.attr, 1875 NULL, 1876 }; 1877 ATTRIBUTE_GROUPS(damon_sysfs_kdamond); 1878 1879 static const struct kobj_type damon_sysfs_kdamond_ktype = { 1880 .release = damon_sysfs_kdamond_release, 1881 .sysfs_ops = &kobj_sysfs_ops, 1882 .default_groups = damon_sysfs_kdamond_groups, 1883 }; 1884 1885 /* 1886 * kdamonds directory 1887 */ 1888 1889 struct damon_sysfs_kdamonds { 1890 struct kobject kobj; 1891 struct damon_sysfs_kdamond **kdamonds_arr; 1892 int nr; 1893 }; 1894 1895 static struct damon_sysfs_kdamonds *damon_sysfs_kdamonds_alloc(void) 1896 { 1897 return kzalloc_obj(struct damon_sysfs_kdamonds); 1898 } 1899 1900 static void damon_sysfs_kdamonds_rm_dirs(struct damon_sysfs_kdamonds *kdamonds) 1901 { 1902 struct damon_sysfs_kdamond **kdamonds_arr = kdamonds->kdamonds_arr; 1903 int i; 1904 1905 for (i = 0; i < kdamonds->nr; i++) { 1906 damon_sysfs_kdamond_rm_dirs(kdamonds_arr[i]); 1907 kobject_put(&kdamonds_arr[i]->kobj); 1908 } 1909 kdamonds->nr = 0; 1910 kfree(kdamonds_arr); 1911 kdamonds->kdamonds_arr = NULL; 1912 } 1913 1914 static bool damon_sysfs_kdamonds_busy(struct damon_sysfs_kdamond **kdamonds, 1915 int nr_kdamonds) 1916 { 1917 int i; 1918 1919 for (i = 0; i < nr_kdamonds; i++) { 1920 if (damon_sysfs_kdamond_running(kdamonds[i])) 1921 return true; 1922 } 1923 1924 return false; 1925 } 1926 1927 static int damon_sysfs_kdamonds_add_dirs(struct damon_sysfs_kdamonds *kdamonds, 1928 int nr_kdamonds) 1929 { 1930 struct damon_sysfs_kdamond **kdamonds_arr, *kdamond; 1931 int err, i; 1932 1933 if (damon_sysfs_kdamonds_busy(kdamonds->kdamonds_arr, kdamonds->nr)) 1934 return -EBUSY; 1935 1936 damon_sysfs_kdamonds_rm_dirs(kdamonds); 1937 if (!nr_kdamonds) 1938 return 0; 1939 1940 kdamonds_arr = kmalloc_objs(*kdamonds_arr, nr_kdamonds, 1941 GFP_KERNEL | __GFP_NOWARN); 1942 if (!kdamonds_arr) 1943 return -ENOMEM; 1944 kdamonds->kdamonds_arr = kdamonds_arr; 1945 1946 for (i = 0; i < nr_kdamonds; i++) { 1947 kdamond = damon_sysfs_kdamond_alloc(); 1948 if (!kdamond) { 1949 damon_sysfs_kdamonds_rm_dirs(kdamonds); 1950 return -ENOMEM; 1951 } 1952 1953 err = kobject_init_and_add(&kdamond->kobj, 1954 &damon_sysfs_kdamond_ktype, &kdamonds->kobj, 1955 "%d", i); 1956 if (err) 1957 goto out; 1958 1959 err = damon_sysfs_kdamond_add_dirs(kdamond); 1960 if (err) 1961 goto out; 1962 1963 kdamonds_arr[i] = kdamond; 1964 kdamonds->nr++; 1965 } 1966 return 0; 1967 1968 out: 1969 damon_sysfs_kdamonds_rm_dirs(kdamonds); 1970 kobject_put(&kdamond->kobj); 1971 return err; 1972 } 1973 1974 static ssize_t nr_kdamonds_show(struct kobject *kobj, 1975 struct kobj_attribute *attr, char *buf) 1976 { 1977 struct damon_sysfs_kdamonds *kdamonds = container_of(kobj, 1978 struct damon_sysfs_kdamonds, kobj); 1979 1980 return sysfs_emit(buf, "%d\n", kdamonds->nr); 1981 } 1982 1983 static ssize_t nr_kdamonds_store(struct kobject *kobj, 1984 struct kobj_attribute *attr, const char *buf, size_t count) 1985 { 1986 struct damon_sysfs_kdamonds *kdamonds; 1987 int nr, err; 1988 1989 err = kstrtoint(buf, 0, &nr); 1990 if (err) 1991 return err; 1992 if (nr < 0) 1993 return -EINVAL; 1994 1995 kdamonds = container_of(kobj, struct damon_sysfs_kdamonds, kobj); 1996 1997 if (!mutex_trylock(&damon_sysfs_lock)) 1998 return -EBUSY; 1999 err = damon_sysfs_kdamonds_add_dirs(kdamonds, nr); 2000 mutex_unlock(&damon_sysfs_lock); 2001 if (err) 2002 return err; 2003 2004 return count; 2005 } 2006 2007 static void damon_sysfs_kdamonds_release(struct kobject *kobj) 2008 { 2009 kfree(container_of(kobj, struct damon_sysfs_kdamonds, kobj)); 2010 } 2011 2012 static struct kobj_attribute damon_sysfs_kdamonds_nr_attr = 2013 __ATTR_RW_MODE(nr_kdamonds, 0600); 2014 2015 static struct attribute *damon_sysfs_kdamonds_attrs[] = { 2016 &damon_sysfs_kdamonds_nr_attr.attr, 2017 NULL, 2018 }; 2019 ATTRIBUTE_GROUPS(damon_sysfs_kdamonds); 2020 2021 static const struct kobj_type damon_sysfs_kdamonds_ktype = { 2022 .release = damon_sysfs_kdamonds_release, 2023 .sysfs_ops = &kobj_sysfs_ops, 2024 .default_groups = damon_sysfs_kdamonds_groups, 2025 }; 2026 2027 /* 2028 * damon user interface directory 2029 */ 2030 2031 struct damon_sysfs_ui_dir { 2032 struct kobject kobj; 2033 struct damon_sysfs_kdamonds *kdamonds; 2034 }; 2035 2036 static struct damon_sysfs_ui_dir *damon_sysfs_ui_dir_alloc(void) 2037 { 2038 return kzalloc_obj(struct damon_sysfs_ui_dir); 2039 } 2040 2041 static int damon_sysfs_ui_dir_add_dirs(struct damon_sysfs_ui_dir *ui_dir) 2042 { 2043 struct damon_sysfs_kdamonds *kdamonds; 2044 int err; 2045 2046 kdamonds = damon_sysfs_kdamonds_alloc(); 2047 if (!kdamonds) 2048 return -ENOMEM; 2049 2050 err = kobject_init_and_add(&kdamonds->kobj, 2051 &damon_sysfs_kdamonds_ktype, &ui_dir->kobj, 2052 "kdamonds"); 2053 if (err) { 2054 kobject_put(&kdamonds->kobj); 2055 return err; 2056 } 2057 ui_dir->kdamonds = kdamonds; 2058 return err; 2059 } 2060 2061 static void damon_sysfs_ui_dir_release(struct kobject *kobj) 2062 { 2063 kfree(container_of(kobj, struct damon_sysfs_ui_dir, kobj)); 2064 } 2065 2066 static struct attribute *damon_sysfs_ui_dir_attrs[] = { 2067 NULL, 2068 }; 2069 ATTRIBUTE_GROUPS(damon_sysfs_ui_dir); 2070 2071 static const struct kobj_type damon_sysfs_ui_dir_ktype = { 2072 .release = damon_sysfs_ui_dir_release, 2073 .sysfs_ops = &kobj_sysfs_ops, 2074 .default_groups = damon_sysfs_ui_dir_groups, 2075 }; 2076 2077 static int __init damon_sysfs_init(void) 2078 { 2079 struct kobject *damon_sysfs_root; 2080 struct damon_sysfs_ui_dir *admin; 2081 int err; 2082 2083 damon_sysfs_root = kobject_create_and_add("damon", mm_kobj); 2084 if (!damon_sysfs_root) 2085 return -ENOMEM; 2086 2087 admin = damon_sysfs_ui_dir_alloc(); 2088 if (!admin) { 2089 kobject_put(damon_sysfs_root); 2090 return -ENOMEM; 2091 } 2092 err = kobject_init_and_add(&admin->kobj, &damon_sysfs_ui_dir_ktype, 2093 damon_sysfs_root, "admin"); 2094 if (err) 2095 goto out; 2096 err = damon_sysfs_ui_dir_add_dirs(admin); 2097 if (err) 2098 goto out; 2099 return 0; 2100 2101 out: 2102 kobject_put(&admin->kobj); 2103 kobject_put(damon_sysfs_root); 2104 return err; 2105 } 2106 subsys_initcall(damon_sysfs_init); 2107 2108 #include "tests/sysfs-kunit.h" 2109