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(sizeof(struct damon_sysfs_region), GFP_KERNEL); 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(sizeof(struct damon_sysfs_regions), GFP_KERNEL); 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_array(nr_regions, sizeof(*regions_arr), 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 }; 216 217 static struct damon_sysfs_target *damon_sysfs_target_alloc(void) 218 { 219 return kzalloc(sizeof(struct damon_sysfs_target), GFP_KERNEL); 220 } 221 222 static int damon_sysfs_target_add_dirs(struct damon_sysfs_target *target) 223 { 224 struct damon_sysfs_regions *regions = damon_sysfs_regions_alloc(); 225 int err; 226 227 if (!regions) 228 return -ENOMEM; 229 230 err = kobject_init_and_add(®ions->kobj, &damon_sysfs_regions_ktype, 231 &target->kobj, "regions"); 232 if (err) 233 kobject_put(®ions->kobj); 234 else 235 target->regions = regions; 236 return err; 237 } 238 239 static void damon_sysfs_target_rm_dirs(struct damon_sysfs_target *target) 240 { 241 damon_sysfs_regions_rm_dirs(target->regions); 242 kobject_put(&target->regions->kobj); 243 } 244 245 static ssize_t pid_target_show(struct kobject *kobj, 246 struct kobj_attribute *attr, char *buf) 247 { 248 struct damon_sysfs_target *target = container_of(kobj, 249 struct damon_sysfs_target, kobj); 250 251 return sysfs_emit(buf, "%d\n", target->pid); 252 } 253 254 static ssize_t pid_target_store(struct kobject *kobj, 255 struct kobj_attribute *attr, const char *buf, size_t count) 256 { 257 struct damon_sysfs_target *target = container_of(kobj, 258 struct damon_sysfs_target, kobj); 259 int err = kstrtoint(buf, 0, &target->pid); 260 261 if (err) 262 return -EINVAL; 263 return count; 264 } 265 266 static void damon_sysfs_target_release(struct kobject *kobj) 267 { 268 kfree(container_of(kobj, struct damon_sysfs_target, kobj)); 269 } 270 271 static struct kobj_attribute damon_sysfs_target_pid_attr = 272 __ATTR_RW_MODE(pid_target, 0600); 273 274 static struct attribute *damon_sysfs_target_attrs[] = { 275 &damon_sysfs_target_pid_attr.attr, 276 NULL, 277 }; 278 ATTRIBUTE_GROUPS(damon_sysfs_target); 279 280 static const struct kobj_type damon_sysfs_target_ktype = { 281 .release = damon_sysfs_target_release, 282 .sysfs_ops = &kobj_sysfs_ops, 283 .default_groups = damon_sysfs_target_groups, 284 }; 285 286 /* 287 * targets directory 288 */ 289 290 struct damon_sysfs_targets { 291 struct kobject kobj; 292 struct damon_sysfs_target **targets_arr; 293 int nr; 294 }; 295 296 static struct damon_sysfs_targets *damon_sysfs_targets_alloc(void) 297 { 298 return kzalloc(sizeof(struct damon_sysfs_targets), GFP_KERNEL); 299 } 300 301 static void damon_sysfs_targets_rm_dirs(struct damon_sysfs_targets *targets) 302 { 303 struct damon_sysfs_target **targets_arr = targets->targets_arr; 304 int i; 305 306 for (i = 0; i < targets->nr; i++) { 307 damon_sysfs_target_rm_dirs(targets_arr[i]); 308 kobject_put(&targets_arr[i]->kobj); 309 } 310 targets->nr = 0; 311 kfree(targets_arr); 312 targets->targets_arr = NULL; 313 } 314 315 static int damon_sysfs_targets_add_dirs(struct damon_sysfs_targets *targets, 316 int nr_targets) 317 { 318 struct damon_sysfs_target **targets_arr, *target; 319 int err, i; 320 321 damon_sysfs_targets_rm_dirs(targets); 322 if (!nr_targets) 323 return 0; 324 325 targets_arr = kmalloc_array(nr_targets, sizeof(*targets_arr), 326 GFP_KERNEL | __GFP_NOWARN); 327 if (!targets_arr) 328 return -ENOMEM; 329 targets->targets_arr = targets_arr; 330 331 for (i = 0; i < nr_targets; i++) { 332 target = damon_sysfs_target_alloc(); 333 if (!target) { 334 damon_sysfs_targets_rm_dirs(targets); 335 return -ENOMEM; 336 } 337 338 err = kobject_init_and_add(&target->kobj, 339 &damon_sysfs_target_ktype, &targets->kobj, 340 "%d", i); 341 if (err) 342 goto out; 343 344 err = damon_sysfs_target_add_dirs(target); 345 if (err) 346 goto out; 347 348 targets_arr[i] = target; 349 targets->nr++; 350 } 351 return 0; 352 353 out: 354 damon_sysfs_targets_rm_dirs(targets); 355 kobject_put(&target->kobj); 356 return err; 357 } 358 359 static ssize_t nr_targets_show(struct kobject *kobj, 360 struct kobj_attribute *attr, char *buf) 361 { 362 struct damon_sysfs_targets *targets = container_of(kobj, 363 struct damon_sysfs_targets, kobj); 364 365 return sysfs_emit(buf, "%d\n", targets->nr); 366 } 367 368 static ssize_t nr_targets_store(struct kobject *kobj, 369 struct kobj_attribute *attr, const char *buf, size_t count) 370 { 371 struct damon_sysfs_targets *targets; 372 int nr, err = kstrtoint(buf, 0, &nr); 373 374 if (err) 375 return err; 376 if (nr < 0) 377 return -EINVAL; 378 379 targets = container_of(kobj, struct damon_sysfs_targets, kobj); 380 381 if (!mutex_trylock(&damon_sysfs_lock)) 382 return -EBUSY; 383 err = damon_sysfs_targets_add_dirs(targets, nr); 384 mutex_unlock(&damon_sysfs_lock); 385 if (err) 386 return err; 387 388 return count; 389 } 390 391 static void damon_sysfs_targets_release(struct kobject *kobj) 392 { 393 kfree(container_of(kobj, struct damon_sysfs_targets, kobj)); 394 } 395 396 static struct kobj_attribute damon_sysfs_targets_nr_attr = 397 __ATTR_RW_MODE(nr_targets, 0600); 398 399 static struct attribute *damon_sysfs_targets_attrs[] = { 400 &damon_sysfs_targets_nr_attr.attr, 401 NULL, 402 }; 403 ATTRIBUTE_GROUPS(damon_sysfs_targets); 404 405 static const struct kobj_type damon_sysfs_targets_ktype = { 406 .release = damon_sysfs_targets_release, 407 .sysfs_ops = &kobj_sysfs_ops, 408 .default_groups = damon_sysfs_targets_groups, 409 }; 410 411 /* 412 * intervals directory 413 */ 414 415 struct damon_sysfs_intervals { 416 struct kobject kobj; 417 unsigned long sample_us; 418 unsigned long aggr_us; 419 unsigned long update_us; 420 }; 421 422 static struct damon_sysfs_intervals *damon_sysfs_intervals_alloc( 423 unsigned long sample_us, unsigned long aggr_us, 424 unsigned long update_us) 425 { 426 struct damon_sysfs_intervals *intervals = kmalloc(sizeof(*intervals), 427 GFP_KERNEL); 428 429 if (!intervals) 430 return NULL; 431 432 intervals->kobj = (struct kobject){}; 433 intervals->sample_us = sample_us; 434 intervals->aggr_us = aggr_us; 435 intervals->update_us = update_us; 436 return intervals; 437 } 438 439 static ssize_t sample_us_show(struct kobject *kobj, 440 struct kobj_attribute *attr, char *buf) 441 { 442 struct damon_sysfs_intervals *intervals = container_of(kobj, 443 struct damon_sysfs_intervals, kobj); 444 445 return sysfs_emit(buf, "%lu\n", intervals->sample_us); 446 } 447 448 static ssize_t sample_us_store(struct kobject *kobj, 449 struct kobj_attribute *attr, const char *buf, size_t count) 450 { 451 struct damon_sysfs_intervals *intervals = container_of(kobj, 452 struct damon_sysfs_intervals, kobj); 453 unsigned long us; 454 int err = kstrtoul(buf, 0, &us); 455 456 if (err) 457 return err; 458 459 intervals->sample_us = us; 460 return count; 461 } 462 463 static ssize_t aggr_us_show(struct kobject *kobj, struct kobj_attribute *attr, 464 char *buf) 465 { 466 struct damon_sysfs_intervals *intervals = container_of(kobj, 467 struct damon_sysfs_intervals, kobj); 468 469 return sysfs_emit(buf, "%lu\n", intervals->aggr_us); 470 } 471 472 static ssize_t aggr_us_store(struct kobject *kobj, struct kobj_attribute *attr, 473 const char *buf, size_t count) 474 { 475 struct damon_sysfs_intervals *intervals = container_of(kobj, 476 struct damon_sysfs_intervals, kobj); 477 unsigned long us; 478 int err = kstrtoul(buf, 0, &us); 479 480 if (err) 481 return err; 482 483 intervals->aggr_us = us; 484 return count; 485 } 486 487 static ssize_t update_us_show(struct kobject *kobj, 488 struct kobj_attribute *attr, char *buf) 489 { 490 struct damon_sysfs_intervals *intervals = container_of(kobj, 491 struct damon_sysfs_intervals, kobj); 492 493 return sysfs_emit(buf, "%lu\n", intervals->update_us); 494 } 495 496 static ssize_t update_us_store(struct kobject *kobj, 497 struct kobj_attribute *attr, const char *buf, size_t count) 498 { 499 struct damon_sysfs_intervals *intervals = container_of(kobj, 500 struct damon_sysfs_intervals, kobj); 501 unsigned long us; 502 int err = kstrtoul(buf, 0, &us); 503 504 if (err) 505 return err; 506 507 intervals->update_us = us; 508 return count; 509 } 510 511 static void damon_sysfs_intervals_release(struct kobject *kobj) 512 { 513 kfree(container_of(kobj, struct damon_sysfs_intervals, kobj)); 514 } 515 516 static struct kobj_attribute damon_sysfs_intervals_sample_us_attr = 517 __ATTR_RW_MODE(sample_us, 0600); 518 519 static struct kobj_attribute damon_sysfs_intervals_aggr_us_attr = 520 __ATTR_RW_MODE(aggr_us, 0600); 521 522 static struct kobj_attribute damon_sysfs_intervals_update_us_attr = 523 __ATTR_RW_MODE(update_us, 0600); 524 525 static struct attribute *damon_sysfs_intervals_attrs[] = { 526 &damon_sysfs_intervals_sample_us_attr.attr, 527 &damon_sysfs_intervals_aggr_us_attr.attr, 528 &damon_sysfs_intervals_update_us_attr.attr, 529 NULL, 530 }; 531 ATTRIBUTE_GROUPS(damon_sysfs_intervals); 532 533 static const struct kobj_type damon_sysfs_intervals_ktype = { 534 .release = damon_sysfs_intervals_release, 535 .sysfs_ops = &kobj_sysfs_ops, 536 .default_groups = damon_sysfs_intervals_groups, 537 }; 538 539 /* 540 * monitoring_attrs directory 541 */ 542 543 struct damon_sysfs_attrs { 544 struct kobject kobj; 545 struct damon_sysfs_intervals *intervals; 546 struct damon_sysfs_ul_range *nr_regions_range; 547 }; 548 549 static struct damon_sysfs_attrs *damon_sysfs_attrs_alloc(void) 550 { 551 struct damon_sysfs_attrs *attrs = kmalloc(sizeof(*attrs), GFP_KERNEL); 552 553 if (!attrs) 554 return NULL; 555 attrs->kobj = (struct kobject){}; 556 return attrs; 557 } 558 559 static int damon_sysfs_attrs_add_dirs(struct damon_sysfs_attrs *attrs) 560 { 561 struct damon_sysfs_intervals *intervals; 562 struct damon_sysfs_ul_range *nr_regions_range; 563 int err; 564 565 intervals = damon_sysfs_intervals_alloc(5000, 100000, 60000000); 566 if (!intervals) 567 return -ENOMEM; 568 569 err = kobject_init_and_add(&intervals->kobj, 570 &damon_sysfs_intervals_ktype, &attrs->kobj, 571 "intervals"); 572 if (err) 573 goto put_intervals_out; 574 attrs->intervals = intervals; 575 576 nr_regions_range = damon_sysfs_ul_range_alloc(10, 1000); 577 if (!nr_regions_range) { 578 err = -ENOMEM; 579 goto put_intervals_out; 580 } 581 582 err = kobject_init_and_add(&nr_regions_range->kobj, 583 &damon_sysfs_ul_range_ktype, &attrs->kobj, 584 "nr_regions"); 585 if (err) 586 goto put_nr_regions_intervals_out; 587 attrs->nr_regions_range = nr_regions_range; 588 return 0; 589 590 put_nr_regions_intervals_out: 591 kobject_put(&nr_regions_range->kobj); 592 attrs->nr_regions_range = NULL; 593 put_intervals_out: 594 kobject_put(&intervals->kobj); 595 attrs->intervals = NULL; 596 return err; 597 } 598 599 static void damon_sysfs_attrs_rm_dirs(struct damon_sysfs_attrs *attrs) 600 { 601 kobject_put(&attrs->nr_regions_range->kobj); 602 kobject_put(&attrs->intervals->kobj); 603 } 604 605 static void damon_sysfs_attrs_release(struct kobject *kobj) 606 { 607 kfree(container_of(kobj, struct damon_sysfs_attrs, kobj)); 608 } 609 610 static struct attribute *damon_sysfs_attrs_attrs[] = { 611 NULL, 612 }; 613 ATTRIBUTE_GROUPS(damon_sysfs_attrs); 614 615 static const struct kobj_type damon_sysfs_attrs_ktype = { 616 .release = damon_sysfs_attrs_release, 617 .sysfs_ops = &kobj_sysfs_ops, 618 .default_groups = damon_sysfs_attrs_groups, 619 }; 620 621 /* 622 * context directory 623 */ 624 625 /* This should match with enum damon_ops_id */ 626 static const char * const damon_sysfs_ops_strs[] = { 627 "vaddr", 628 "fvaddr", 629 "paddr", 630 }; 631 632 struct damon_sysfs_context { 633 struct kobject kobj; 634 enum damon_ops_id ops_id; 635 struct damon_sysfs_attrs *attrs; 636 struct damon_sysfs_targets *targets; 637 struct damon_sysfs_schemes *schemes; 638 }; 639 640 static struct damon_sysfs_context *damon_sysfs_context_alloc( 641 enum damon_ops_id ops_id) 642 { 643 struct damon_sysfs_context *context = kmalloc(sizeof(*context), 644 GFP_KERNEL); 645 646 if (!context) 647 return NULL; 648 context->kobj = (struct kobject){}; 649 context->ops_id = ops_id; 650 return context; 651 } 652 653 static int damon_sysfs_context_set_attrs(struct damon_sysfs_context *context) 654 { 655 struct damon_sysfs_attrs *attrs = damon_sysfs_attrs_alloc(); 656 int err; 657 658 if (!attrs) 659 return -ENOMEM; 660 err = kobject_init_and_add(&attrs->kobj, &damon_sysfs_attrs_ktype, 661 &context->kobj, "monitoring_attrs"); 662 if (err) 663 goto out; 664 err = damon_sysfs_attrs_add_dirs(attrs); 665 if (err) 666 goto out; 667 context->attrs = attrs; 668 return 0; 669 670 out: 671 kobject_put(&attrs->kobj); 672 return err; 673 } 674 675 static int damon_sysfs_context_set_targets(struct damon_sysfs_context *context) 676 { 677 struct damon_sysfs_targets *targets = damon_sysfs_targets_alloc(); 678 int err; 679 680 if (!targets) 681 return -ENOMEM; 682 err = kobject_init_and_add(&targets->kobj, &damon_sysfs_targets_ktype, 683 &context->kobj, "targets"); 684 if (err) { 685 kobject_put(&targets->kobj); 686 return err; 687 } 688 context->targets = targets; 689 return 0; 690 } 691 692 static int damon_sysfs_context_set_schemes(struct damon_sysfs_context *context) 693 { 694 struct damon_sysfs_schemes *schemes = damon_sysfs_schemes_alloc(); 695 int err; 696 697 if (!schemes) 698 return -ENOMEM; 699 err = kobject_init_and_add(&schemes->kobj, &damon_sysfs_schemes_ktype, 700 &context->kobj, "schemes"); 701 if (err) { 702 kobject_put(&schemes->kobj); 703 return err; 704 } 705 context->schemes = schemes; 706 return 0; 707 } 708 709 static int damon_sysfs_context_add_dirs(struct damon_sysfs_context *context) 710 { 711 int err; 712 713 err = damon_sysfs_context_set_attrs(context); 714 if (err) 715 return err; 716 717 err = damon_sysfs_context_set_targets(context); 718 if (err) 719 goto put_attrs_out; 720 721 err = damon_sysfs_context_set_schemes(context); 722 if (err) 723 goto put_targets_attrs_out; 724 return 0; 725 726 put_targets_attrs_out: 727 kobject_put(&context->targets->kobj); 728 context->targets = NULL; 729 put_attrs_out: 730 kobject_put(&context->attrs->kobj); 731 context->attrs = NULL; 732 return err; 733 } 734 735 static void damon_sysfs_context_rm_dirs(struct damon_sysfs_context *context) 736 { 737 damon_sysfs_attrs_rm_dirs(context->attrs); 738 kobject_put(&context->attrs->kobj); 739 damon_sysfs_targets_rm_dirs(context->targets); 740 kobject_put(&context->targets->kobj); 741 damon_sysfs_schemes_rm_dirs(context->schemes); 742 kobject_put(&context->schemes->kobj); 743 } 744 745 static ssize_t avail_operations_show(struct kobject *kobj, 746 struct kobj_attribute *attr, char *buf) 747 { 748 enum damon_ops_id id; 749 int len = 0; 750 751 for (id = 0; id < NR_DAMON_OPS; id++) { 752 if (!damon_is_registered_ops(id)) 753 continue; 754 len += sysfs_emit_at(buf, len, "%s\n", 755 damon_sysfs_ops_strs[id]); 756 } 757 return len; 758 } 759 760 static ssize_t operations_show(struct kobject *kobj, 761 struct kobj_attribute *attr, char *buf) 762 { 763 struct damon_sysfs_context *context = container_of(kobj, 764 struct damon_sysfs_context, kobj); 765 766 return sysfs_emit(buf, "%s\n", damon_sysfs_ops_strs[context->ops_id]); 767 } 768 769 static ssize_t operations_store(struct kobject *kobj, 770 struct kobj_attribute *attr, const char *buf, size_t count) 771 { 772 struct damon_sysfs_context *context = container_of(kobj, 773 struct damon_sysfs_context, kobj); 774 enum damon_ops_id id; 775 776 for (id = 0; id < NR_DAMON_OPS; id++) { 777 if (sysfs_streq(buf, damon_sysfs_ops_strs[id])) { 778 context->ops_id = id; 779 return count; 780 } 781 } 782 return -EINVAL; 783 } 784 785 static void damon_sysfs_context_release(struct kobject *kobj) 786 { 787 kfree(container_of(kobj, struct damon_sysfs_context, kobj)); 788 } 789 790 static struct kobj_attribute damon_sysfs_context_avail_operations_attr = 791 __ATTR_RO_MODE(avail_operations, 0400); 792 793 static struct kobj_attribute damon_sysfs_context_operations_attr = 794 __ATTR_RW_MODE(operations, 0600); 795 796 static struct attribute *damon_sysfs_context_attrs[] = { 797 &damon_sysfs_context_avail_operations_attr.attr, 798 &damon_sysfs_context_operations_attr.attr, 799 NULL, 800 }; 801 ATTRIBUTE_GROUPS(damon_sysfs_context); 802 803 static const struct kobj_type damon_sysfs_context_ktype = { 804 .release = damon_sysfs_context_release, 805 .sysfs_ops = &kobj_sysfs_ops, 806 .default_groups = damon_sysfs_context_groups, 807 }; 808 809 /* 810 * contexts directory 811 */ 812 813 struct damon_sysfs_contexts { 814 struct kobject kobj; 815 struct damon_sysfs_context **contexts_arr; 816 int nr; 817 }; 818 819 static struct damon_sysfs_contexts *damon_sysfs_contexts_alloc(void) 820 { 821 return kzalloc(sizeof(struct damon_sysfs_contexts), GFP_KERNEL); 822 } 823 824 static void damon_sysfs_contexts_rm_dirs(struct damon_sysfs_contexts *contexts) 825 { 826 struct damon_sysfs_context **contexts_arr = contexts->contexts_arr; 827 int i; 828 829 for (i = 0; i < contexts->nr; i++) { 830 damon_sysfs_context_rm_dirs(contexts_arr[i]); 831 kobject_put(&contexts_arr[i]->kobj); 832 } 833 contexts->nr = 0; 834 kfree(contexts_arr); 835 contexts->contexts_arr = NULL; 836 } 837 838 static int damon_sysfs_contexts_add_dirs(struct damon_sysfs_contexts *contexts, 839 int nr_contexts) 840 { 841 struct damon_sysfs_context **contexts_arr, *context; 842 int err, i; 843 844 damon_sysfs_contexts_rm_dirs(contexts); 845 if (!nr_contexts) 846 return 0; 847 848 contexts_arr = kmalloc_array(nr_contexts, sizeof(*contexts_arr), 849 GFP_KERNEL | __GFP_NOWARN); 850 if (!contexts_arr) 851 return -ENOMEM; 852 contexts->contexts_arr = contexts_arr; 853 854 for (i = 0; i < nr_contexts; i++) { 855 context = damon_sysfs_context_alloc(DAMON_OPS_VADDR); 856 if (!context) { 857 damon_sysfs_contexts_rm_dirs(contexts); 858 return -ENOMEM; 859 } 860 861 err = kobject_init_and_add(&context->kobj, 862 &damon_sysfs_context_ktype, &contexts->kobj, 863 "%d", i); 864 if (err) 865 goto out; 866 867 err = damon_sysfs_context_add_dirs(context); 868 if (err) 869 goto out; 870 871 contexts_arr[i] = context; 872 contexts->nr++; 873 } 874 return 0; 875 876 out: 877 damon_sysfs_contexts_rm_dirs(contexts); 878 kobject_put(&context->kobj); 879 return err; 880 } 881 882 static ssize_t nr_contexts_show(struct kobject *kobj, 883 struct kobj_attribute *attr, char *buf) 884 { 885 struct damon_sysfs_contexts *contexts = container_of(kobj, 886 struct damon_sysfs_contexts, kobj); 887 888 return sysfs_emit(buf, "%d\n", contexts->nr); 889 } 890 891 static ssize_t nr_contexts_store(struct kobject *kobj, 892 struct kobj_attribute *attr, const char *buf, size_t count) 893 { 894 struct damon_sysfs_contexts *contexts; 895 int nr, err; 896 897 err = kstrtoint(buf, 0, &nr); 898 if (err) 899 return err; 900 /* TODO: support multiple contexts per kdamond */ 901 if (nr < 0 || 1 < nr) 902 return -EINVAL; 903 904 contexts = container_of(kobj, struct damon_sysfs_contexts, kobj); 905 if (!mutex_trylock(&damon_sysfs_lock)) 906 return -EBUSY; 907 err = damon_sysfs_contexts_add_dirs(contexts, nr); 908 mutex_unlock(&damon_sysfs_lock); 909 if (err) 910 return err; 911 912 return count; 913 } 914 915 static void damon_sysfs_contexts_release(struct kobject *kobj) 916 { 917 kfree(container_of(kobj, struct damon_sysfs_contexts, kobj)); 918 } 919 920 static struct kobj_attribute damon_sysfs_contexts_nr_attr 921 = __ATTR_RW_MODE(nr_contexts, 0600); 922 923 static struct attribute *damon_sysfs_contexts_attrs[] = { 924 &damon_sysfs_contexts_nr_attr.attr, 925 NULL, 926 }; 927 ATTRIBUTE_GROUPS(damon_sysfs_contexts); 928 929 static const struct kobj_type damon_sysfs_contexts_ktype = { 930 .release = damon_sysfs_contexts_release, 931 .sysfs_ops = &kobj_sysfs_ops, 932 .default_groups = damon_sysfs_contexts_groups, 933 }; 934 935 /* 936 * kdamond directory 937 */ 938 939 struct damon_sysfs_kdamond { 940 struct kobject kobj; 941 struct damon_sysfs_contexts *contexts; 942 struct damon_ctx *damon_ctx; 943 }; 944 945 static struct damon_sysfs_kdamond *damon_sysfs_kdamond_alloc(void) 946 { 947 return kzalloc(sizeof(struct damon_sysfs_kdamond), GFP_KERNEL); 948 } 949 950 static int damon_sysfs_kdamond_add_dirs(struct damon_sysfs_kdamond *kdamond) 951 { 952 struct damon_sysfs_contexts *contexts; 953 int err; 954 955 contexts = damon_sysfs_contexts_alloc(); 956 if (!contexts) 957 return -ENOMEM; 958 959 err = kobject_init_and_add(&contexts->kobj, 960 &damon_sysfs_contexts_ktype, &kdamond->kobj, 961 "contexts"); 962 if (err) { 963 kobject_put(&contexts->kobj); 964 return err; 965 } 966 kdamond->contexts = contexts; 967 968 return err; 969 } 970 971 static void damon_sysfs_kdamond_rm_dirs(struct damon_sysfs_kdamond *kdamond) 972 { 973 damon_sysfs_contexts_rm_dirs(kdamond->contexts); 974 kobject_put(&kdamond->contexts->kobj); 975 } 976 977 static bool damon_sysfs_ctx_running(struct damon_ctx *ctx) 978 { 979 bool running; 980 981 mutex_lock(&ctx->kdamond_lock); 982 running = ctx->kdamond != NULL; 983 mutex_unlock(&ctx->kdamond_lock); 984 return running; 985 } 986 987 /* 988 * enum damon_sysfs_cmd - Commands for a specific kdamond. 989 */ 990 enum damon_sysfs_cmd { 991 /* @DAMON_SYSFS_CMD_ON: Turn the kdamond on. */ 992 DAMON_SYSFS_CMD_ON, 993 /* @DAMON_SYSFS_CMD_OFF: Turn the kdamond off. */ 994 DAMON_SYSFS_CMD_OFF, 995 /* @DAMON_SYSFS_CMD_COMMIT: Update kdamond inputs. */ 996 DAMON_SYSFS_CMD_COMMIT, 997 /* 998 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS: Update scheme stats sysfs 999 * files. 1000 */ 1001 DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS, 1002 /* 1003 * @DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS: Update schemes tried 1004 * regions 1005 */ 1006 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS, 1007 /* 1008 * @DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS: Clear schemes tried 1009 * regions 1010 */ 1011 DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS, 1012 /* 1013 * @NR_DAMON_SYSFS_CMDS: Total number of DAMON sysfs commands. 1014 */ 1015 NR_DAMON_SYSFS_CMDS, 1016 }; 1017 1018 /* Should match with enum damon_sysfs_cmd */ 1019 static const char * const damon_sysfs_cmd_strs[] = { 1020 "on", 1021 "off", 1022 "commit", 1023 "update_schemes_stats", 1024 "update_schemes_tried_regions", 1025 "clear_schemes_tried_regions", 1026 }; 1027 1028 /* 1029 * struct damon_sysfs_cmd_request - A request to the DAMON callback. 1030 * @cmd: The command that needs to be handled by the callback. 1031 * @kdamond: The kobject wrapper that associated to the kdamond thread. 1032 * 1033 * This structure represents a sysfs command request that need to access some 1034 * DAMON context-internal data. Because DAMON context-internal data can be 1035 * safely accessed from DAMON callbacks without additional synchronization, the 1036 * request will be handled by the DAMON callback. None-``NULL`` @kdamond means 1037 * the request is valid. 1038 */ 1039 struct damon_sysfs_cmd_request { 1040 enum damon_sysfs_cmd cmd; 1041 struct damon_sysfs_kdamond *kdamond; 1042 }; 1043 1044 /* Current DAMON callback request. Protected by damon_sysfs_lock. */ 1045 static struct damon_sysfs_cmd_request damon_sysfs_cmd_request; 1046 1047 static ssize_t state_show(struct kobject *kobj, struct kobj_attribute *attr, 1048 char *buf) 1049 { 1050 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1051 struct damon_sysfs_kdamond, kobj); 1052 struct damon_ctx *ctx = kdamond->damon_ctx; 1053 bool running; 1054 1055 if (!ctx) 1056 running = false; 1057 else 1058 running = damon_sysfs_ctx_running(ctx); 1059 1060 return sysfs_emit(buf, "%s\n", running ? 1061 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_ON] : 1062 damon_sysfs_cmd_strs[DAMON_SYSFS_CMD_OFF]); 1063 } 1064 1065 static int damon_sysfs_set_attrs(struct damon_ctx *ctx, 1066 struct damon_sysfs_attrs *sys_attrs) 1067 { 1068 struct damon_sysfs_intervals *sys_intervals = sys_attrs->intervals; 1069 struct damon_sysfs_ul_range *sys_nr_regions = 1070 sys_attrs->nr_regions_range; 1071 struct damon_attrs attrs = { 1072 .sample_interval = sys_intervals->sample_us, 1073 .aggr_interval = sys_intervals->aggr_us, 1074 .ops_update_interval = sys_intervals->update_us, 1075 .min_nr_regions = sys_nr_regions->min, 1076 .max_nr_regions = sys_nr_regions->max, 1077 }; 1078 return damon_set_attrs(ctx, &attrs); 1079 } 1080 1081 static void damon_sysfs_destroy_targets(struct damon_ctx *ctx) 1082 { 1083 struct damon_target *t, *next; 1084 bool has_pid = damon_target_has_pid(ctx); 1085 1086 damon_for_each_target_safe(t, next, ctx) { 1087 if (has_pid) 1088 put_pid(t->pid); 1089 damon_destroy_target(t); 1090 } 1091 } 1092 1093 static int damon_sysfs_set_regions(struct damon_target *t, 1094 struct damon_sysfs_regions *sysfs_regions) 1095 { 1096 struct damon_addr_range *ranges = kmalloc_array(sysfs_regions->nr, 1097 sizeof(*ranges), GFP_KERNEL | __GFP_NOWARN); 1098 int i, err = -EINVAL; 1099 1100 if (!ranges) 1101 return -ENOMEM; 1102 for (i = 0; i < sysfs_regions->nr; i++) { 1103 struct damon_sysfs_region *sys_region = 1104 sysfs_regions->regions_arr[i]; 1105 1106 if (sys_region->ar.start > sys_region->ar.end) 1107 goto out; 1108 1109 ranges[i].start = sys_region->ar.start; 1110 ranges[i].end = sys_region->ar.end; 1111 if (i == 0) 1112 continue; 1113 if (ranges[i - 1].end > ranges[i].start) 1114 goto out; 1115 } 1116 err = damon_set_regions(t, ranges, sysfs_regions->nr); 1117 out: 1118 kfree(ranges); 1119 return err; 1120 1121 } 1122 1123 static int damon_sysfs_add_target(struct damon_sysfs_target *sys_target, 1124 struct damon_ctx *ctx) 1125 { 1126 struct damon_target *t = damon_new_target(); 1127 int err = -EINVAL; 1128 1129 if (!t) 1130 return -ENOMEM; 1131 damon_add_target(ctx, t); 1132 if (damon_target_has_pid(ctx)) { 1133 t->pid = find_get_pid(sys_target->pid); 1134 if (!t->pid) 1135 goto destroy_targets_out; 1136 } 1137 err = damon_sysfs_set_regions(t, sys_target->regions); 1138 if (err) 1139 goto destroy_targets_out; 1140 return 0; 1141 1142 destroy_targets_out: 1143 damon_sysfs_destroy_targets(ctx); 1144 return err; 1145 } 1146 1147 /* 1148 * Search a target in a context that corresponds to the sysfs target input. 1149 * 1150 * Return: pointer to the target if found, NULL if not found, or negative 1151 * error code if the search failed. 1152 */ 1153 static struct damon_target *damon_sysfs_existing_target( 1154 struct damon_sysfs_target *sys_target, struct damon_ctx *ctx) 1155 { 1156 struct pid *pid; 1157 struct damon_target *t; 1158 1159 if (!damon_target_has_pid(ctx)) { 1160 /* Up to only one target for paddr could exist */ 1161 damon_for_each_target(t, ctx) 1162 return t; 1163 return NULL; 1164 } 1165 1166 /* ops.id should be DAMON_OPS_VADDR or DAMON_OPS_FVADDR */ 1167 pid = find_get_pid(sys_target->pid); 1168 if (!pid) 1169 return ERR_PTR(-EINVAL); 1170 damon_for_each_target(t, ctx) { 1171 if (t->pid == pid) { 1172 put_pid(pid); 1173 return t; 1174 } 1175 } 1176 put_pid(pid); 1177 return NULL; 1178 } 1179 1180 static int damon_sysfs_set_targets(struct damon_ctx *ctx, 1181 struct damon_sysfs_targets *sysfs_targets) 1182 { 1183 int i, err; 1184 1185 /* Multiple physical address space monitoring targets makes no sense */ 1186 if (ctx->ops.id == DAMON_OPS_PADDR && sysfs_targets->nr > 1) 1187 return -EINVAL; 1188 1189 for (i = 0; i < sysfs_targets->nr; i++) { 1190 struct damon_sysfs_target *st = sysfs_targets->targets_arr[i]; 1191 struct damon_target *t = damon_sysfs_existing_target(st, ctx); 1192 1193 if (IS_ERR(t)) 1194 return PTR_ERR(t); 1195 if (!t) 1196 err = damon_sysfs_add_target(st, ctx); 1197 else 1198 err = damon_sysfs_set_regions(t, st->regions); 1199 if (err) 1200 return err; 1201 } 1202 return 0; 1203 } 1204 1205 static void damon_sysfs_before_terminate(struct damon_ctx *ctx) 1206 { 1207 struct damon_target *t, *next; 1208 struct damon_sysfs_kdamond *kdamond; 1209 1210 /* damon_sysfs_schemes_update_regions_stop() might not yet called */ 1211 kdamond = damon_sysfs_cmd_request.kdamond; 1212 if (kdamond && damon_sysfs_cmd_request.cmd == 1213 DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS && 1214 ctx == kdamond->damon_ctx) { 1215 damon_sysfs_schemes_update_regions_stop(ctx); 1216 mutex_unlock(&damon_sysfs_lock); 1217 } 1218 1219 if (!damon_target_has_pid(ctx)) 1220 return; 1221 1222 mutex_lock(&ctx->kdamond_lock); 1223 damon_for_each_target_safe(t, next, ctx) { 1224 put_pid(t->pid); 1225 damon_destroy_target(t); 1226 } 1227 mutex_unlock(&ctx->kdamond_lock); 1228 } 1229 1230 /* 1231 * damon_sysfs_upd_schemes_stats() - Update schemes stats sysfs files. 1232 * @kdamond: The kobject wrapper that associated to the kdamond thread. 1233 * 1234 * This function reads the schemes stats of specific kdamond and update the 1235 * related values for sysfs files. This function should be called from DAMON 1236 * callbacks while holding ``damon_syfs_lock``, to safely access the DAMON 1237 * contexts-internal data and DAMON sysfs variables. 1238 */ 1239 static int damon_sysfs_upd_schemes_stats(struct damon_sysfs_kdamond *kdamond) 1240 { 1241 struct damon_ctx *ctx = kdamond->damon_ctx; 1242 1243 if (!ctx) 1244 return -EINVAL; 1245 damon_sysfs_schemes_update_stats( 1246 kdamond->contexts->contexts_arr[0]->schemes, ctx); 1247 return 0; 1248 } 1249 1250 static int damon_sysfs_upd_schemes_regions_start( 1251 struct damon_sysfs_kdamond *kdamond) 1252 { 1253 struct damon_ctx *ctx = kdamond->damon_ctx; 1254 1255 if (!ctx) 1256 return -EINVAL; 1257 return damon_sysfs_schemes_update_regions_start( 1258 kdamond->contexts->contexts_arr[0]->schemes, ctx); 1259 } 1260 1261 static int damon_sysfs_upd_schemes_regions_stop( 1262 struct damon_sysfs_kdamond *kdamond) 1263 { 1264 struct damon_ctx *ctx = kdamond->damon_ctx; 1265 1266 if (!ctx) 1267 return -EINVAL; 1268 return damon_sysfs_schemes_update_regions_stop(ctx); 1269 } 1270 1271 static int damon_sysfs_clear_schemes_regions( 1272 struct damon_sysfs_kdamond *kdamond) 1273 { 1274 struct damon_ctx *ctx = kdamond->damon_ctx; 1275 1276 if (!ctx) 1277 return -EINVAL; 1278 return damon_sysfs_schemes_clear_regions( 1279 kdamond->contexts->contexts_arr[0]->schemes, ctx); 1280 } 1281 1282 static inline bool damon_sysfs_kdamond_running( 1283 struct damon_sysfs_kdamond *kdamond) 1284 { 1285 return kdamond->damon_ctx && 1286 damon_sysfs_ctx_running(kdamond->damon_ctx); 1287 } 1288 1289 static int damon_sysfs_apply_inputs(struct damon_ctx *ctx, 1290 struct damon_sysfs_context *sys_ctx) 1291 { 1292 int err; 1293 1294 err = damon_select_ops(ctx, sys_ctx->ops_id); 1295 if (err) 1296 return err; 1297 err = damon_sysfs_set_attrs(ctx, sys_ctx->attrs); 1298 if (err) 1299 return err; 1300 err = damon_sysfs_set_targets(ctx, sys_ctx->targets); 1301 if (err) 1302 return err; 1303 return damon_sysfs_set_schemes(ctx, sys_ctx->schemes); 1304 } 1305 1306 /* 1307 * damon_sysfs_commit_input() - Commit user inputs to a running kdamond. 1308 * @kdamond: The kobject wrapper for the associated kdamond. 1309 * 1310 * If the sysfs input is wrong, the kdamond will be terminated. 1311 */ 1312 static int damon_sysfs_commit_input(struct damon_sysfs_kdamond *kdamond) 1313 { 1314 if (!damon_sysfs_kdamond_running(kdamond)) 1315 return -EINVAL; 1316 /* TODO: Support multiple contexts per kdamond */ 1317 if (kdamond->contexts->nr != 1) 1318 return -EINVAL; 1319 1320 return damon_sysfs_apply_inputs(kdamond->damon_ctx, 1321 kdamond->contexts->contexts_arr[0]); 1322 } 1323 1324 /* 1325 * damon_sysfs_cmd_request_callback() - DAMON callback for handling requests. 1326 * @c: The DAMON context of the callback. 1327 * 1328 * This function is periodically called back from the kdamond thread for @c. 1329 * Then, it checks if there is a waiting DAMON sysfs request and handles it. 1330 */ 1331 static int damon_sysfs_cmd_request_callback(struct damon_ctx *c) 1332 { 1333 struct damon_sysfs_kdamond *kdamond; 1334 static bool damon_sysfs_schemes_regions_updating; 1335 int err = 0; 1336 1337 /* avoid deadlock due to concurrent state_store('off') */ 1338 if (!damon_sysfs_schemes_regions_updating && 1339 !mutex_trylock(&damon_sysfs_lock)) 1340 return 0; 1341 kdamond = damon_sysfs_cmd_request.kdamond; 1342 if (!kdamond || kdamond->damon_ctx != c) 1343 goto out; 1344 switch (damon_sysfs_cmd_request.cmd) { 1345 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_STATS: 1346 err = damon_sysfs_upd_schemes_stats(kdamond); 1347 break; 1348 case DAMON_SYSFS_CMD_COMMIT: 1349 err = damon_sysfs_commit_input(kdamond); 1350 break; 1351 case DAMON_SYSFS_CMD_UPDATE_SCHEMES_TRIED_REGIONS: 1352 if (!damon_sysfs_schemes_regions_updating) { 1353 err = damon_sysfs_upd_schemes_regions_start(kdamond); 1354 if (!err) { 1355 damon_sysfs_schemes_regions_updating = true; 1356 goto keep_lock_out; 1357 } 1358 } else { 1359 err = damon_sysfs_upd_schemes_regions_stop(kdamond); 1360 damon_sysfs_schemes_regions_updating = false; 1361 } 1362 break; 1363 case DAMON_SYSFS_CMD_CLEAR_SCHEMES_TRIED_REGIONS: 1364 err = damon_sysfs_clear_schemes_regions(kdamond); 1365 break; 1366 default: 1367 break; 1368 } 1369 /* Mark the request as invalid now. */ 1370 damon_sysfs_cmd_request.kdamond = NULL; 1371 out: 1372 if (!damon_sysfs_schemes_regions_updating) 1373 mutex_unlock(&damon_sysfs_lock); 1374 keep_lock_out: 1375 return err; 1376 } 1377 1378 static struct damon_ctx *damon_sysfs_build_ctx( 1379 struct damon_sysfs_context *sys_ctx) 1380 { 1381 struct damon_ctx *ctx = damon_new_ctx(); 1382 int err; 1383 1384 if (!ctx) 1385 return ERR_PTR(-ENOMEM); 1386 1387 err = damon_sysfs_apply_inputs(ctx, sys_ctx); 1388 if (err) { 1389 damon_destroy_ctx(ctx); 1390 return ERR_PTR(err); 1391 } 1392 1393 ctx->callback.after_wmarks_check = damon_sysfs_cmd_request_callback; 1394 ctx->callback.after_aggregation = damon_sysfs_cmd_request_callback; 1395 ctx->callback.before_terminate = damon_sysfs_before_terminate; 1396 return ctx; 1397 } 1398 1399 static int damon_sysfs_turn_damon_on(struct damon_sysfs_kdamond *kdamond) 1400 { 1401 struct damon_ctx *ctx; 1402 int err; 1403 1404 if (damon_sysfs_kdamond_running(kdamond)) 1405 return -EBUSY; 1406 if (damon_sysfs_cmd_request.kdamond == kdamond) 1407 return -EBUSY; 1408 /* TODO: support multiple contexts per kdamond */ 1409 if (kdamond->contexts->nr != 1) 1410 return -EINVAL; 1411 1412 if (kdamond->damon_ctx) 1413 damon_destroy_ctx(kdamond->damon_ctx); 1414 kdamond->damon_ctx = NULL; 1415 1416 ctx = damon_sysfs_build_ctx(kdamond->contexts->contexts_arr[0]); 1417 if (IS_ERR(ctx)) 1418 return PTR_ERR(ctx); 1419 err = damon_start(&ctx, 1, false); 1420 if (err) { 1421 damon_destroy_ctx(ctx); 1422 return err; 1423 } 1424 kdamond->damon_ctx = ctx; 1425 return err; 1426 } 1427 1428 static int damon_sysfs_turn_damon_off(struct damon_sysfs_kdamond *kdamond) 1429 { 1430 if (!kdamond->damon_ctx) 1431 return -EINVAL; 1432 return damon_stop(&kdamond->damon_ctx, 1); 1433 /* 1434 * To allow users show final monitoring results of already turned-off 1435 * DAMON, we free kdamond->damon_ctx in next 1436 * damon_sysfs_turn_damon_on(), or kdamonds_nr_store() 1437 */ 1438 } 1439 1440 /* 1441 * damon_sysfs_handle_cmd() - Handle a command for a specific kdamond. 1442 * @cmd: The command to handle. 1443 * @kdamond: The kobject wrapper for the associated kdamond. 1444 * 1445 * This function handles a DAMON sysfs command for a kdamond. For commands 1446 * that need to access running DAMON context-internal data, it requests 1447 * handling of the command to the DAMON callback 1448 * (@damon_sysfs_cmd_request_callback()) and wait until it is properly handled, 1449 * or the context is completed. 1450 * 1451 * Return: 0 on success, negative error code otherwise. 1452 */ 1453 static int damon_sysfs_handle_cmd(enum damon_sysfs_cmd cmd, 1454 struct damon_sysfs_kdamond *kdamond) 1455 { 1456 bool need_wait = true; 1457 1458 /* Handle commands that doesn't access DAMON context-internal data */ 1459 switch (cmd) { 1460 case DAMON_SYSFS_CMD_ON: 1461 return damon_sysfs_turn_damon_on(kdamond); 1462 case DAMON_SYSFS_CMD_OFF: 1463 return damon_sysfs_turn_damon_off(kdamond); 1464 default: 1465 break; 1466 } 1467 1468 /* Pass the command to DAMON callback for safe DAMON context access */ 1469 if (damon_sysfs_cmd_request.kdamond) 1470 return -EBUSY; 1471 if (!damon_sysfs_kdamond_running(kdamond)) 1472 return -EINVAL; 1473 damon_sysfs_cmd_request.cmd = cmd; 1474 damon_sysfs_cmd_request.kdamond = kdamond; 1475 1476 /* 1477 * wait until damon_sysfs_cmd_request_callback() handles the request 1478 * from kdamond context 1479 */ 1480 mutex_unlock(&damon_sysfs_lock); 1481 while (need_wait) { 1482 schedule_timeout_idle(msecs_to_jiffies(100)); 1483 if (!mutex_trylock(&damon_sysfs_lock)) 1484 continue; 1485 if (!damon_sysfs_cmd_request.kdamond) { 1486 /* damon_sysfs_cmd_request_callback() handled */ 1487 need_wait = false; 1488 } else if (!damon_sysfs_kdamond_running(kdamond)) { 1489 /* kdamond has already finished */ 1490 need_wait = false; 1491 damon_sysfs_cmd_request.kdamond = NULL; 1492 } 1493 mutex_unlock(&damon_sysfs_lock); 1494 } 1495 mutex_lock(&damon_sysfs_lock); 1496 return 0; 1497 } 1498 1499 static ssize_t state_store(struct kobject *kobj, struct kobj_attribute *attr, 1500 const char *buf, size_t count) 1501 { 1502 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1503 struct damon_sysfs_kdamond, kobj); 1504 enum damon_sysfs_cmd cmd; 1505 ssize_t ret = -EINVAL; 1506 1507 if (!mutex_trylock(&damon_sysfs_lock)) 1508 return -EBUSY; 1509 for (cmd = 0; cmd < NR_DAMON_SYSFS_CMDS; cmd++) { 1510 if (sysfs_streq(buf, damon_sysfs_cmd_strs[cmd])) { 1511 ret = damon_sysfs_handle_cmd(cmd, kdamond); 1512 break; 1513 } 1514 } 1515 mutex_unlock(&damon_sysfs_lock); 1516 if (!ret) 1517 ret = count; 1518 return ret; 1519 } 1520 1521 static ssize_t pid_show(struct kobject *kobj, 1522 struct kobj_attribute *attr, char *buf) 1523 { 1524 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1525 struct damon_sysfs_kdamond, kobj); 1526 struct damon_ctx *ctx; 1527 int pid = -1; 1528 1529 if (!mutex_trylock(&damon_sysfs_lock)) 1530 return -EBUSY; 1531 ctx = kdamond->damon_ctx; 1532 if (!ctx) 1533 goto out; 1534 1535 mutex_lock(&ctx->kdamond_lock); 1536 if (ctx->kdamond) 1537 pid = ctx->kdamond->pid; 1538 mutex_unlock(&ctx->kdamond_lock); 1539 out: 1540 mutex_unlock(&damon_sysfs_lock); 1541 return sysfs_emit(buf, "%d\n", pid); 1542 } 1543 1544 static void damon_sysfs_kdamond_release(struct kobject *kobj) 1545 { 1546 struct damon_sysfs_kdamond *kdamond = container_of(kobj, 1547 struct damon_sysfs_kdamond, kobj); 1548 1549 if (kdamond->damon_ctx) 1550 damon_destroy_ctx(kdamond->damon_ctx); 1551 kfree(kdamond); 1552 } 1553 1554 static struct kobj_attribute damon_sysfs_kdamond_state_attr = 1555 __ATTR_RW_MODE(state, 0600); 1556 1557 static struct kobj_attribute damon_sysfs_kdamond_pid_attr = 1558 __ATTR_RO_MODE(pid, 0400); 1559 1560 static struct attribute *damon_sysfs_kdamond_attrs[] = { 1561 &damon_sysfs_kdamond_state_attr.attr, 1562 &damon_sysfs_kdamond_pid_attr.attr, 1563 NULL, 1564 }; 1565 ATTRIBUTE_GROUPS(damon_sysfs_kdamond); 1566 1567 static const struct kobj_type damon_sysfs_kdamond_ktype = { 1568 .release = damon_sysfs_kdamond_release, 1569 .sysfs_ops = &kobj_sysfs_ops, 1570 .default_groups = damon_sysfs_kdamond_groups, 1571 }; 1572 1573 /* 1574 * kdamonds directory 1575 */ 1576 1577 struct damon_sysfs_kdamonds { 1578 struct kobject kobj; 1579 struct damon_sysfs_kdamond **kdamonds_arr; 1580 int nr; 1581 }; 1582 1583 static struct damon_sysfs_kdamonds *damon_sysfs_kdamonds_alloc(void) 1584 { 1585 return kzalloc(sizeof(struct damon_sysfs_kdamonds), GFP_KERNEL); 1586 } 1587 1588 static void damon_sysfs_kdamonds_rm_dirs(struct damon_sysfs_kdamonds *kdamonds) 1589 { 1590 struct damon_sysfs_kdamond **kdamonds_arr = kdamonds->kdamonds_arr; 1591 int i; 1592 1593 for (i = 0; i < kdamonds->nr; i++) { 1594 damon_sysfs_kdamond_rm_dirs(kdamonds_arr[i]); 1595 kobject_put(&kdamonds_arr[i]->kobj); 1596 } 1597 kdamonds->nr = 0; 1598 kfree(kdamonds_arr); 1599 kdamonds->kdamonds_arr = NULL; 1600 } 1601 1602 static bool damon_sysfs_kdamonds_busy(struct damon_sysfs_kdamond **kdamonds, 1603 int nr_kdamonds) 1604 { 1605 int i; 1606 1607 for (i = 0; i < nr_kdamonds; i++) { 1608 if (damon_sysfs_kdamond_running(kdamonds[i]) || 1609 damon_sysfs_cmd_request.kdamond == kdamonds[i]) 1610 return true; 1611 } 1612 1613 return false; 1614 } 1615 1616 static int damon_sysfs_kdamonds_add_dirs(struct damon_sysfs_kdamonds *kdamonds, 1617 int nr_kdamonds) 1618 { 1619 struct damon_sysfs_kdamond **kdamonds_arr, *kdamond; 1620 int err, i; 1621 1622 if (damon_sysfs_kdamonds_busy(kdamonds->kdamonds_arr, kdamonds->nr)) 1623 return -EBUSY; 1624 1625 damon_sysfs_kdamonds_rm_dirs(kdamonds); 1626 if (!nr_kdamonds) 1627 return 0; 1628 1629 kdamonds_arr = kmalloc_array(nr_kdamonds, sizeof(*kdamonds_arr), 1630 GFP_KERNEL | __GFP_NOWARN); 1631 if (!kdamonds_arr) 1632 return -ENOMEM; 1633 kdamonds->kdamonds_arr = kdamonds_arr; 1634 1635 for (i = 0; i < nr_kdamonds; i++) { 1636 kdamond = damon_sysfs_kdamond_alloc(); 1637 if (!kdamond) { 1638 damon_sysfs_kdamonds_rm_dirs(kdamonds); 1639 return -ENOMEM; 1640 } 1641 1642 err = kobject_init_and_add(&kdamond->kobj, 1643 &damon_sysfs_kdamond_ktype, &kdamonds->kobj, 1644 "%d", i); 1645 if (err) 1646 goto out; 1647 1648 err = damon_sysfs_kdamond_add_dirs(kdamond); 1649 if (err) 1650 goto out; 1651 1652 kdamonds_arr[i] = kdamond; 1653 kdamonds->nr++; 1654 } 1655 return 0; 1656 1657 out: 1658 damon_sysfs_kdamonds_rm_dirs(kdamonds); 1659 kobject_put(&kdamond->kobj); 1660 return err; 1661 } 1662 1663 static ssize_t nr_kdamonds_show(struct kobject *kobj, 1664 struct kobj_attribute *attr, char *buf) 1665 { 1666 struct damon_sysfs_kdamonds *kdamonds = container_of(kobj, 1667 struct damon_sysfs_kdamonds, kobj); 1668 1669 return sysfs_emit(buf, "%d\n", kdamonds->nr); 1670 } 1671 1672 static ssize_t nr_kdamonds_store(struct kobject *kobj, 1673 struct kobj_attribute *attr, const char *buf, size_t count) 1674 { 1675 struct damon_sysfs_kdamonds *kdamonds; 1676 int nr, err; 1677 1678 err = kstrtoint(buf, 0, &nr); 1679 if (err) 1680 return err; 1681 if (nr < 0) 1682 return -EINVAL; 1683 1684 kdamonds = container_of(kobj, struct damon_sysfs_kdamonds, kobj); 1685 1686 if (!mutex_trylock(&damon_sysfs_lock)) 1687 return -EBUSY; 1688 err = damon_sysfs_kdamonds_add_dirs(kdamonds, nr); 1689 mutex_unlock(&damon_sysfs_lock); 1690 if (err) 1691 return err; 1692 1693 return count; 1694 } 1695 1696 static void damon_sysfs_kdamonds_release(struct kobject *kobj) 1697 { 1698 kfree(container_of(kobj, struct damon_sysfs_kdamonds, kobj)); 1699 } 1700 1701 static struct kobj_attribute damon_sysfs_kdamonds_nr_attr = 1702 __ATTR_RW_MODE(nr_kdamonds, 0600); 1703 1704 static struct attribute *damon_sysfs_kdamonds_attrs[] = { 1705 &damon_sysfs_kdamonds_nr_attr.attr, 1706 NULL, 1707 }; 1708 ATTRIBUTE_GROUPS(damon_sysfs_kdamonds); 1709 1710 static const struct kobj_type damon_sysfs_kdamonds_ktype = { 1711 .release = damon_sysfs_kdamonds_release, 1712 .sysfs_ops = &kobj_sysfs_ops, 1713 .default_groups = damon_sysfs_kdamonds_groups, 1714 }; 1715 1716 /* 1717 * damon user interface directory 1718 */ 1719 1720 struct damon_sysfs_ui_dir { 1721 struct kobject kobj; 1722 struct damon_sysfs_kdamonds *kdamonds; 1723 }; 1724 1725 static struct damon_sysfs_ui_dir *damon_sysfs_ui_dir_alloc(void) 1726 { 1727 return kzalloc(sizeof(struct damon_sysfs_ui_dir), GFP_KERNEL); 1728 } 1729 1730 static int damon_sysfs_ui_dir_add_dirs(struct damon_sysfs_ui_dir *ui_dir) 1731 { 1732 struct damon_sysfs_kdamonds *kdamonds; 1733 int err; 1734 1735 kdamonds = damon_sysfs_kdamonds_alloc(); 1736 if (!kdamonds) 1737 return -ENOMEM; 1738 1739 err = kobject_init_and_add(&kdamonds->kobj, 1740 &damon_sysfs_kdamonds_ktype, &ui_dir->kobj, 1741 "kdamonds"); 1742 if (err) { 1743 kobject_put(&kdamonds->kobj); 1744 return err; 1745 } 1746 ui_dir->kdamonds = kdamonds; 1747 return err; 1748 } 1749 1750 static void damon_sysfs_ui_dir_release(struct kobject *kobj) 1751 { 1752 kfree(container_of(kobj, struct damon_sysfs_ui_dir, kobj)); 1753 } 1754 1755 static struct attribute *damon_sysfs_ui_dir_attrs[] = { 1756 NULL, 1757 }; 1758 ATTRIBUTE_GROUPS(damon_sysfs_ui_dir); 1759 1760 static const struct kobj_type damon_sysfs_ui_dir_ktype = { 1761 .release = damon_sysfs_ui_dir_release, 1762 .sysfs_ops = &kobj_sysfs_ops, 1763 .default_groups = damon_sysfs_ui_dir_groups, 1764 }; 1765 1766 static int __init damon_sysfs_init(void) 1767 { 1768 struct kobject *damon_sysfs_root; 1769 struct damon_sysfs_ui_dir *admin; 1770 int err; 1771 1772 damon_sysfs_root = kobject_create_and_add("damon", mm_kobj); 1773 if (!damon_sysfs_root) 1774 return -ENOMEM; 1775 1776 admin = damon_sysfs_ui_dir_alloc(); 1777 if (!admin) { 1778 kobject_put(damon_sysfs_root); 1779 return -ENOMEM; 1780 } 1781 err = kobject_init_and_add(&admin->kobj, &damon_sysfs_ui_dir_ktype, 1782 damon_sysfs_root, "admin"); 1783 if (err) 1784 goto out; 1785 err = damon_sysfs_ui_dir_add_dirs(admin); 1786 if (err) 1787 goto out; 1788 return 0; 1789 1790 out: 1791 kobject_put(&admin->kobj); 1792 kobject_put(damon_sysfs_root); 1793 return err; 1794 } 1795 subsys_initcall(damon_sysfs_init); 1796