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/slab.h> 9 10 #include "sysfs-common.h" 11 12 /* 13 * scheme region directory 14 */ 15 16 struct damon_sysfs_scheme_region { 17 struct kobject kobj; 18 struct damon_addr_range ar; 19 unsigned int nr_accesses; 20 unsigned int age; 21 struct list_head list; 22 }; 23 24 static struct damon_sysfs_scheme_region *damon_sysfs_scheme_region_alloc( 25 struct damon_region *region) 26 { 27 struct damon_sysfs_scheme_region *sysfs_region = kmalloc( 28 sizeof(*sysfs_region), GFP_KERNEL); 29 30 if (!sysfs_region) 31 return NULL; 32 sysfs_region->kobj = (struct kobject){}; 33 sysfs_region->ar = region->ar; 34 sysfs_region->nr_accesses = region->nr_accesses; 35 sysfs_region->age = region->age; 36 INIT_LIST_HEAD(&sysfs_region->list); 37 return sysfs_region; 38 } 39 40 static ssize_t start_show(struct kobject *kobj, struct kobj_attribute *attr, 41 char *buf) 42 { 43 struct damon_sysfs_scheme_region *region = container_of(kobj, 44 struct damon_sysfs_scheme_region, kobj); 45 46 return sysfs_emit(buf, "%lu\n", region->ar.start); 47 } 48 49 static ssize_t end_show(struct kobject *kobj, struct kobj_attribute *attr, 50 char *buf) 51 { 52 struct damon_sysfs_scheme_region *region = container_of(kobj, 53 struct damon_sysfs_scheme_region, kobj); 54 55 return sysfs_emit(buf, "%lu\n", region->ar.end); 56 } 57 58 static ssize_t nr_accesses_show(struct kobject *kobj, 59 struct kobj_attribute *attr, char *buf) 60 { 61 struct damon_sysfs_scheme_region *region = container_of(kobj, 62 struct damon_sysfs_scheme_region, kobj); 63 64 return sysfs_emit(buf, "%u\n", region->nr_accesses); 65 } 66 67 static ssize_t age_show(struct kobject *kobj, struct kobj_attribute *attr, 68 char *buf) 69 { 70 struct damon_sysfs_scheme_region *region = container_of(kobj, 71 struct damon_sysfs_scheme_region, kobj); 72 73 return sysfs_emit(buf, "%u\n", region->age); 74 } 75 76 static void damon_sysfs_scheme_region_release(struct kobject *kobj) 77 { 78 struct damon_sysfs_scheme_region *region = container_of(kobj, 79 struct damon_sysfs_scheme_region, kobj); 80 81 list_del(®ion->list); 82 kfree(region); 83 } 84 85 static struct kobj_attribute damon_sysfs_scheme_region_start_attr = 86 __ATTR_RO_MODE(start, 0400); 87 88 static struct kobj_attribute damon_sysfs_scheme_region_end_attr = 89 __ATTR_RO_MODE(end, 0400); 90 91 static struct kobj_attribute damon_sysfs_scheme_region_nr_accesses_attr = 92 __ATTR_RO_MODE(nr_accesses, 0400); 93 94 static struct kobj_attribute damon_sysfs_scheme_region_age_attr = 95 __ATTR_RO_MODE(age, 0400); 96 97 static struct attribute *damon_sysfs_scheme_region_attrs[] = { 98 &damon_sysfs_scheme_region_start_attr.attr, 99 &damon_sysfs_scheme_region_end_attr.attr, 100 &damon_sysfs_scheme_region_nr_accesses_attr.attr, 101 &damon_sysfs_scheme_region_age_attr.attr, 102 NULL, 103 }; 104 ATTRIBUTE_GROUPS(damon_sysfs_scheme_region); 105 106 static const struct kobj_type damon_sysfs_scheme_region_ktype = { 107 .release = damon_sysfs_scheme_region_release, 108 .sysfs_ops = &kobj_sysfs_ops, 109 .default_groups = damon_sysfs_scheme_region_groups, 110 }; 111 112 /* 113 * scheme regions directory 114 */ 115 116 struct damon_sysfs_scheme_regions { 117 struct kobject kobj; 118 struct list_head regions_list; 119 int nr_regions; 120 }; 121 122 static struct damon_sysfs_scheme_regions * 123 damon_sysfs_scheme_regions_alloc(void) 124 { 125 struct damon_sysfs_scheme_regions *regions = kmalloc(sizeof(*regions), 126 GFP_KERNEL); 127 128 regions->kobj = (struct kobject){}; 129 INIT_LIST_HEAD(®ions->regions_list); 130 regions->nr_regions = 0; 131 return regions; 132 } 133 134 static void damon_sysfs_scheme_regions_rm_dirs( 135 struct damon_sysfs_scheme_regions *regions) 136 { 137 struct damon_sysfs_scheme_region *r, *next; 138 139 list_for_each_entry_safe(r, next, ®ions->regions_list, list) { 140 /* release function deletes it from the list */ 141 kobject_put(&r->kobj); 142 regions->nr_regions--; 143 } 144 } 145 146 static void damon_sysfs_scheme_regions_release(struct kobject *kobj) 147 { 148 kfree(container_of(kobj, struct damon_sysfs_scheme_regions, kobj)); 149 } 150 151 static struct attribute *damon_sysfs_scheme_regions_attrs[] = { 152 NULL, 153 }; 154 ATTRIBUTE_GROUPS(damon_sysfs_scheme_regions); 155 156 static const struct kobj_type damon_sysfs_scheme_regions_ktype = { 157 .release = damon_sysfs_scheme_regions_release, 158 .sysfs_ops = &kobj_sysfs_ops, 159 .default_groups = damon_sysfs_scheme_regions_groups, 160 }; 161 162 /* 163 * schemes/stats directory 164 */ 165 166 struct damon_sysfs_stats { 167 struct kobject kobj; 168 unsigned long nr_tried; 169 unsigned long sz_tried; 170 unsigned long nr_applied; 171 unsigned long sz_applied; 172 unsigned long qt_exceeds; 173 }; 174 175 static struct damon_sysfs_stats *damon_sysfs_stats_alloc(void) 176 { 177 return kzalloc(sizeof(struct damon_sysfs_stats), GFP_KERNEL); 178 } 179 180 static ssize_t nr_tried_show(struct kobject *kobj, struct kobj_attribute *attr, 181 char *buf) 182 { 183 struct damon_sysfs_stats *stats = container_of(kobj, 184 struct damon_sysfs_stats, kobj); 185 186 return sysfs_emit(buf, "%lu\n", stats->nr_tried); 187 } 188 189 static ssize_t sz_tried_show(struct kobject *kobj, struct kobj_attribute *attr, 190 char *buf) 191 { 192 struct damon_sysfs_stats *stats = container_of(kobj, 193 struct damon_sysfs_stats, kobj); 194 195 return sysfs_emit(buf, "%lu\n", stats->sz_tried); 196 } 197 198 static ssize_t nr_applied_show(struct kobject *kobj, 199 struct kobj_attribute *attr, char *buf) 200 { 201 struct damon_sysfs_stats *stats = container_of(kobj, 202 struct damon_sysfs_stats, kobj); 203 204 return sysfs_emit(buf, "%lu\n", stats->nr_applied); 205 } 206 207 static ssize_t sz_applied_show(struct kobject *kobj, 208 struct kobj_attribute *attr, char *buf) 209 { 210 struct damon_sysfs_stats *stats = container_of(kobj, 211 struct damon_sysfs_stats, kobj); 212 213 return sysfs_emit(buf, "%lu\n", stats->sz_applied); 214 } 215 216 static ssize_t qt_exceeds_show(struct kobject *kobj, 217 struct kobj_attribute *attr, char *buf) 218 { 219 struct damon_sysfs_stats *stats = container_of(kobj, 220 struct damon_sysfs_stats, kobj); 221 222 return sysfs_emit(buf, "%lu\n", stats->qt_exceeds); 223 } 224 225 static void damon_sysfs_stats_release(struct kobject *kobj) 226 { 227 kfree(container_of(kobj, struct damon_sysfs_stats, kobj)); 228 } 229 230 static struct kobj_attribute damon_sysfs_stats_nr_tried_attr = 231 __ATTR_RO_MODE(nr_tried, 0400); 232 233 static struct kobj_attribute damon_sysfs_stats_sz_tried_attr = 234 __ATTR_RO_MODE(sz_tried, 0400); 235 236 static struct kobj_attribute damon_sysfs_stats_nr_applied_attr = 237 __ATTR_RO_MODE(nr_applied, 0400); 238 239 static struct kobj_attribute damon_sysfs_stats_sz_applied_attr = 240 __ATTR_RO_MODE(sz_applied, 0400); 241 242 static struct kobj_attribute damon_sysfs_stats_qt_exceeds_attr = 243 __ATTR_RO_MODE(qt_exceeds, 0400); 244 245 static struct attribute *damon_sysfs_stats_attrs[] = { 246 &damon_sysfs_stats_nr_tried_attr.attr, 247 &damon_sysfs_stats_sz_tried_attr.attr, 248 &damon_sysfs_stats_nr_applied_attr.attr, 249 &damon_sysfs_stats_sz_applied_attr.attr, 250 &damon_sysfs_stats_qt_exceeds_attr.attr, 251 NULL, 252 }; 253 ATTRIBUTE_GROUPS(damon_sysfs_stats); 254 255 static const struct kobj_type damon_sysfs_stats_ktype = { 256 .release = damon_sysfs_stats_release, 257 .sysfs_ops = &kobj_sysfs_ops, 258 .default_groups = damon_sysfs_stats_groups, 259 }; 260 261 /* 262 * filter directory 263 */ 264 265 struct damon_sysfs_scheme_filter { 266 struct kobject kobj; 267 enum damos_filter_type type; 268 bool matching; 269 char *memcg_path; 270 }; 271 272 static struct damon_sysfs_scheme_filter *damon_sysfs_scheme_filter_alloc(void) 273 { 274 return kzalloc(sizeof(struct damon_sysfs_scheme_filter), GFP_KERNEL); 275 } 276 277 /* Should match with enum damos_filter_type */ 278 static const char * const damon_sysfs_scheme_filter_type_strs[] = { 279 "anon", 280 "memcg", 281 }; 282 283 static ssize_t type_show(struct kobject *kobj, 284 struct kobj_attribute *attr, char *buf) 285 { 286 struct damon_sysfs_scheme_filter *filter = container_of(kobj, 287 struct damon_sysfs_scheme_filter, kobj); 288 289 return sysfs_emit(buf, "%s\n", 290 damon_sysfs_scheme_filter_type_strs[filter->type]); 291 } 292 293 static ssize_t type_store(struct kobject *kobj, 294 struct kobj_attribute *attr, const char *buf, size_t count) 295 { 296 struct damon_sysfs_scheme_filter *filter = container_of(kobj, 297 struct damon_sysfs_scheme_filter, kobj); 298 enum damos_filter_type type; 299 ssize_t ret = -EINVAL; 300 301 for (type = 0; type < NR_DAMOS_FILTER_TYPES; type++) { 302 if (sysfs_streq(buf, damon_sysfs_scheme_filter_type_strs[ 303 type])) { 304 filter->type = type; 305 ret = count; 306 break; 307 } 308 } 309 return ret; 310 } 311 312 static ssize_t matching_show(struct kobject *kobj, 313 struct kobj_attribute *attr, char *buf) 314 { 315 struct damon_sysfs_scheme_filter *filter = container_of(kobj, 316 struct damon_sysfs_scheme_filter, kobj); 317 318 return sysfs_emit(buf, "%c\n", filter->matching ? 'Y' : 'N'); 319 } 320 321 static ssize_t matching_store(struct kobject *kobj, 322 struct kobj_attribute *attr, const char *buf, size_t count) 323 { 324 struct damon_sysfs_scheme_filter *filter = container_of(kobj, 325 struct damon_sysfs_scheme_filter, kobj); 326 bool matching; 327 int err = kstrtobool(buf, &matching); 328 329 if (err) 330 return err; 331 332 filter->matching = matching; 333 return count; 334 } 335 336 static ssize_t memcg_path_show(struct kobject *kobj, 337 struct kobj_attribute *attr, char *buf) 338 { 339 struct damon_sysfs_scheme_filter *filter = container_of(kobj, 340 struct damon_sysfs_scheme_filter, kobj); 341 342 return sysfs_emit(buf, "%s\n", 343 filter->memcg_path ? filter->memcg_path : ""); 344 } 345 346 static ssize_t memcg_path_store(struct kobject *kobj, 347 struct kobj_attribute *attr, const char *buf, size_t count) 348 { 349 struct damon_sysfs_scheme_filter *filter = container_of(kobj, 350 struct damon_sysfs_scheme_filter, kobj); 351 char *path = kmalloc(sizeof(*path) * (count + 1), GFP_KERNEL); 352 353 if (!path) 354 return -ENOMEM; 355 356 strscpy(path, buf, count + 1); 357 filter->memcg_path = path; 358 return count; 359 } 360 361 static void damon_sysfs_scheme_filter_release(struct kobject *kobj) 362 { 363 struct damon_sysfs_scheme_filter *filter = container_of(kobj, 364 struct damon_sysfs_scheme_filter, kobj); 365 366 kfree(filter->memcg_path); 367 kfree(filter); 368 } 369 370 static struct kobj_attribute damon_sysfs_scheme_filter_type_attr = 371 __ATTR_RW_MODE(type, 0600); 372 373 static struct kobj_attribute damon_sysfs_scheme_filter_matching_attr = 374 __ATTR_RW_MODE(matching, 0600); 375 376 static struct kobj_attribute damon_sysfs_scheme_filter_memcg_path_attr = 377 __ATTR_RW_MODE(memcg_path, 0600); 378 379 static struct attribute *damon_sysfs_scheme_filter_attrs[] = { 380 &damon_sysfs_scheme_filter_type_attr.attr, 381 &damon_sysfs_scheme_filter_matching_attr.attr, 382 &damon_sysfs_scheme_filter_memcg_path_attr.attr, 383 NULL, 384 }; 385 ATTRIBUTE_GROUPS(damon_sysfs_scheme_filter); 386 387 static const struct kobj_type damon_sysfs_scheme_filter_ktype = { 388 .release = damon_sysfs_scheme_filter_release, 389 .sysfs_ops = &kobj_sysfs_ops, 390 .default_groups = damon_sysfs_scheme_filter_groups, 391 }; 392 393 /* 394 * filters directory 395 */ 396 397 struct damon_sysfs_scheme_filters { 398 struct kobject kobj; 399 struct damon_sysfs_scheme_filter **filters_arr; 400 int nr; 401 }; 402 403 static struct damon_sysfs_scheme_filters * 404 damon_sysfs_scheme_filters_alloc(void) 405 { 406 return kzalloc(sizeof(struct damon_sysfs_scheme_filters), GFP_KERNEL); 407 } 408 409 static void damon_sysfs_scheme_filters_rm_dirs( 410 struct damon_sysfs_scheme_filters *filters) 411 { 412 struct damon_sysfs_scheme_filter **filters_arr = filters->filters_arr; 413 int i; 414 415 for (i = 0; i < filters->nr; i++) 416 kobject_put(&filters_arr[i]->kobj); 417 filters->nr = 0; 418 kfree(filters_arr); 419 filters->filters_arr = NULL; 420 } 421 422 static int damon_sysfs_scheme_filters_add_dirs( 423 struct damon_sysfs_scheme_filters *filters, int nr_filters) 424 { 425 struct damon_sysfs_scheme_filter **filters_arr, *filter; 426 int err, i; 427 428 damon_sysfs_scheme_filters_rm_dirs(filters); 429 if (!nr_filters) 430 return 0; 431 432 filters_arr = kmalloc_array(nr_filters, sizeof(*filters_arr), 433 GFP_KERNEL | __GFP_NOWARN); 434 if (!filters_arr) 435 return -ENOMEM; 436 filters->filters_arr = filters_arr; 437 438 for (i = 0; i < nr_filters; i++) { 439 filter = damon_sysfs_scheme_filter_alloc(); 440 if (!filter) { 441 damon_sysfs_scheme_filters_rm_dirs(filters); 442 return -ENOMEM; 443 } 444 445 err = kobject_init_and_add(&filter->kobj, 446 &damon_sysfs_scheme_filter_ktype, 447 &filters->kobj, "%d", i); 448 if (err) { 449 kobject_put(&filter->kobj); 450 damon_sysfs_scheme_filters_rm_dirs(filters); 451 return err; 452 } 453 454 filters_arr[i] = filter; 455 filters->nr++; 456 } 457 return 0; 458 } 459 460 static ssize_t nr_filters_show(struct kobject *kobj, 461 struct kobj_attribute *attr, char *buf) 462 { 463 struct damon_sysfs_scheme_filters *filters = container_of(kobj, 464 struct damon_sysfs_scheme_filters, kobj); 465 466 return sysfs_emit(buf, "%d\n", filters->nr); 467 } 468 469 static ssize_t nr_filters_store(struct kobject *kobj, 470 struct kobj_attribute *attr, const char *buf, size_t count) 471 { 472 struct damon_sysfs_scheme_filters *filters; 473 int nr, err = kstrtoint(buf, 0, &nr); 474 475 if (err) 476 return err; 477 if (nr < 0) 478 return -EINVAL; 479 480 filters = container_of(kobj, struct damon_sysfs_scheme_filters, kobj); 481 482 if (!mutex_trylock(&damon_sysfs_lock)) 483 return -EBUSY; 484 err = damon_sysfs_scheme_filters_add_dirs(filters, nr); 485 mutex_unlock(&damon_sysfs_lock); 486 if (err) 487 return err; 488 489 return count; 490 } 491 492 static void damon_sysfs_scheme_filters_release(struct kobject *kobj) 493 { 494 kfree(container_of(kobj, struct damon_sysfs_scheme_filters, kobj)); 495 } 496 497 static struct kobj_attribute damon_sysfs_scheme_filters_nr_attr = 498 __ATTR_RW_MODE(nr_filters, 0600); 499 500 static struct attribute *damon_sysfs_scheme_filters_attrs[] = { 501 &damon_sysfs_scheme_filters_nr_attr.attr, 502 NULL, 503 }; 504 ATTRIBUTE_GROUPS(damon_sysfs_scheme_filters); 505 506 static const struct kobj_type damon_sysfs_scheme_filters_ktype = { 507 .release = damon_sysfs_scheme_filters_release, 508 .sysfs_ops = &kobj_sysfs_ops, 509 .default_groups = damon_sysfs_scheme_filters_groups, 510 }; 511 512 /* 513 * watermarks directory 514 */ 515 516 struct damon_sysfs_watermarks { 517 struct kobject kobj; 518 enum damos_wmark_metric metric; 519 unsigned long interval_us; 520 unsigned long high; 521 unsigned long mid; 522 unsigned long low; 523 }; 524 525 static struct damon_sysfs_watermarks *damon_sysfs_watermarks_alloc( 526 enum damos_wmark_metric metric, unsigned long interval_us, 527 unsigned long high, unsigned long mid, unsigned long low) 528 { 529 struct damon_sysfs_watermarks *watermarks = kmalloc( 530 sizeof(*watermarks), GFP_KERNEL); 531 532 if (!watermarks) 533 return NULL; 534 watermarks->kobj = (struct kobject){}; 535 watermarks->metric = metric; 536 watermarks->interval_us = interval_us; 537 watermarks->high = high; 538 watermarks->mid = mid; 539 watermarks->low = low; 540 return watermarks; 541 } 542 543 /* Should match with enum damos_wmark_metric */ 544 static const char * const damon_sysfs_wmark_metric_strs[] = { 545 "none", 546 "free_mem_rate", 547 }; 548 549 static ssize_t metric_show(struct kobject *kobj, struct kobj_attribute *attr, 550 char *buf) 551 { 552 struct damon_sysfs_watermarks *watermarks = container_of(kobj, 553 struct damon_sysfs_watermarks, kobj); 554 555 return sysfs_emit(buf, "%s\n", 556 damon_sysfs_wmark_metric_strs[watermarks->metric]); 557 } 558 559 static ssize_t metric_store(struct kobject *kobj, struct kobj_attribute *attr, 560 const char *buf, size_t count) 561 { 562 struct damon_sysfs_watermarks *watermarks = container_of(kobj, 563 struct damon_sysfs_watermarks, kobj); 564 enum damos_wmark_metric metric; 565 566 for (metric = 0; metric < NR_DAMOS_WMARK_METRICS; metric++) { 567 if (sysfs_streq(buf, damon_sysfs_wmark_metric_strs[metric])) { 568 watermarks->metric = metric; 569 return count; 570 } 571 } 572 return -EINVAL; 573 } 574 575 static ssize_t interval_us_show(struct kobject *kobj, 576 struct kobj_attribute *attr, char *buf) 577 { 578 struct damon_sysfs_watermarks *watermarks = container_of(kobj, 579 struct damon_sysfs_watermarks, kobj); 580 581 return sysfs_emit(buf, "%lu\n", watermarks->interval_us); 582 } 583 584 static ssize_t interval_us_store(struct kobject *kobj, 585 struct kobj_attribute *attr, const char *buf, size_t count) 586 { 587 struct damon_sysfs_watermarks *watermarks = container_of(kobj, 588 struct damon_sysfs_watermarks, kobj); 589 int err = kstrtoul(buf, 0, &watermarks->interval_us); 590 591 return err ? err : count; 592 } 593 594 static ssize_t high_show(struct kobject *kobj, 595 struct kobj_attribute *attr, char *buf) 596 { 597 struct damon_sysfs_watermarks *watermarks = container_of(kobj, 598 struct damon_sysfs_watermarks, kobj); 599 600 return sysfs_emit(buf, "%lu\n", watermarks->high); 601 } 602 603 static ssize_t high_store(struct kobject *kobj, 604 struct kobj_attribute *attr, const char *buf, size_t count) 605 { 606 struct damon_sysfs_watermarks *watermarks = container_of(kobj, 607 struct damon_sysfs_watermarks, kobj); 608 int err = kstrtoul(buf, 0, &watermarks->high); 609 610 return err ? err : count; 611 } 612 613 static ssize_t mid_show(struct kobject *kobj, 614 struct kobj_attribute *attr, char *buf) 615 { 616 struct damon_sysfs_watermarks *watermarks = container_of(kobj, 617 struct damon_sysfs_watermarks, kobj); 618 619 return sysfs_emit(buf, "%lu\n", watermarks->mid); 620 } 621 622 static ssize_t mid_store(struct kobject *kobj, 623 struct kobj_attribute *attr, const char *buf, size_t count) 624 { 625 struct damon_sysfs_watermarks *watermarks = container_of(kobj, 626 struct damon_sysfs_watermarks, kobj); 627 int err = kstrtoul(buf, 0, &watermarks->mid); 628 629 return err ? err : count; 630 } 631 632 static ssize_t low_show(struct kobject *kobj, 633 struct kobj_attribute *attr, char *buf) 634 { 635 struct damon_sysfs_watermarks *watermarks = container_of(kobj, 636 struct damon_sysfs_watermarks, kobj); 637 638 return sysfs_emit(buf, "%lu\n", watermarks->low); 639 } 640 641 static ssize_t low_store(struct kobject *kobj, 642 struct kobj_attribute *attr, const char *buf, size_t count) 643 { 644 struct damon_sysfs_watermarks *watermarks = container_of(kobj, 645 struct damon_sysfs_watermarks, kobj); 646 int err = kstrtoul(buf, 0, &watermarks->low); 647 648 return err ? err : count; 649 } 650 651 static void damon_sysfs_watermarks_release(struct kobject *kobj) 652 { 653 kfree(container_of(kobj, struct damon_sysfs_watermarks, kobj)); 654 } 655 656 static struct kobj_attribute damon_sysfs_watermarks_metric_attr = 657 __ATTR_RW_MODE(metric, 0600); 658 659 static struct kobj_attribute damon_sysfs_watermarks_interval_us_attr = 660 __ATTR_RW_MODE(interval_us, 0600); 661 662 static struct kobj_attribute damon_sysfs_watermarks_high_attr = 663 __ATTR_RW_MODE(high, 0600); 664 665 static struct kobj_attribute damon_sysfs_watermarks_mid_attr = 666 __ATTR_RW_MODE(mid, 0600); 667 668 static struct kobj_attribute damon_sysfs_watermarks_low_attr = 669 __ATTR_RW_MODE(low, 0600); 670 671 static struct attribute *damon_sysfs_watermarks_attrs[] = { 672 &damon_sysfs_watermarks_metric_attr.attr, 673 &damon_sysfs_watermarks_interval_us_attr.attr, 674 &damon_sysfs_watermarks_high_attr.attr, 675 &damon_sysfs_watermarks_mid_attr.attr, 676 &damon_sysfs_watermarks_low_attr.attr, 677 NULL, 678 }; 679 ATTRIBUTE_GROUPS(damon_sysfs_watermarks); 680 681 static const struct kobj_type damon_sysfs_watermarks_ktype = { 682 .release = damon_sysfs_watermarks_release, 683 .sysfs_ops = &kobj_sysfs_ops, 684 .default_groups = damon_sysfs_watermarks_groups, 685 }; 686 687 /* 688 * scheme/weights directory 689 */ 690 691 struct damon_sysfs_weights { 692 struct kobject kobj; 693 unsigned int sz; 694 unsigned int nr_accesses; 695 unsigned int age; 696 }; 697 698 static struct damon_sysfs_weights *damon_sysfs_weights_alloc(unsigned int sz, 699 unsigned int nr_accesses, unsigned int age) 700 { 701 struct damon_sysfs_weights *weights = kmalloc(sizeof(*weights), 702 GFP_KERNEL); 703 704 if (!weights) 705 return NULL; 706 weights->kobj = (struct kobject){}; 707 weights->sz = sz; 708 weights->nr_accesses = nr_accesses; 709 weights->age = age; 710 return weights; 711 } 712 713 static ssize_t sz_permil_show(struct kobject *kobj, 714 struct kobj_attribute *attr, char *buf) 715 { 716 struct damon_sysfs_weights *weights = container_of(kobj, 717 struct damon_sysfs_weights, kobj); 718 719 return sysfs_emit(buf, "%u\n", weights->sz); 720 } 721 722 static ssize_t sz_permil_store(struct kobject *kobj, 723 struct kobj_attribute *attr, const char *buf, size_t count) 724 { 725 struct damon_sysfs_weights *weights = container_of(kobj, 726 struct damon_sysfs_weights, kobj); 727 int err = kstrtouint(buf, 0, &weights->sz); 728 729 return err ? err : count; 730 } 731 732 static ssize_t nr_accesses_permil_show(struct kobject *kobj, 733 struct kobj_attribute *attr, char *buf) 734 { 735 struct damon_sysfs_weights *weights = container_of(kobj, 736 struct damon_sysfs_weights, kobj); 737 738 return sysfs_emit(buf, "%u\n", weights->nr_accesses); 739 } 740 741 static ssize_t nr_accesses_permil_store(struct kobject *kobj, 742 struct kobj_attribute *attr, const char *buf, size_t count) 743 { 744 struct damon_sysfs_weights *weights = container_of(kobj, 745 struct damon_sysfs_weights, kobj); 746 int err = kstrtouint(buf, 0, &weights->nr_accesses); 747 748 return err ? err : count; 749 } 750 751 static ssize_t age_permil_show(struct kobject *kobj, 752 struct kobj_attribute *attr, char *buf) 753 { 754 struct damon_sysfs_weights *weights = container_of(kobj, 755 struct damon_sysfs_weights, kobj); 756 757 return sysfs_emit(buf, "%u\n", weights->age); 758 } 759 760 static ssize_t age_permil_store(struct kobject *kobj, 761 struct kobj_attribute *attr, const char *buf, size_t count) 762 { 763 struct damon_sysfs_weights *weights = container_of(kobj, 764 struct damon_sysfs_weights, kobj); 765 int err = kstrtouint(buf, 0, &weights->age); 766 767 return err ? err : count; 768 } 769 770 static void damon_sysfs_weights_release(struct kobject *kobj) 771 { 772 kfree(container_of(kobj, struct damon_sysfs_weights, kobj)); 773 } 774 775 static struct kobj_attribute damon_sysfs_weights_sz_attr = 776 __ATTR_RW_MODE(sz_permil, 0600); 777 778 static struct kobj_attribute damon_sysfs_weights_nr_accesses_attr = 779 __ATTR_RW_MODE(nr_accesses_permil, 0600); 780 781 static struct kobj_attribute damon_sysfs_weights_age_attr = 782 __ATTR_RW_MODE(age_permil, 0600); 783 784 static struct attribute *damon_sysfs_weights_attrs[] = { 785 &damon_sysfs_weights_sz_attr.attr, 786 &damon_sysfs_weights_nr_accesses_attr.attr, 787 &damon_sysfs_weights_age_attr.attr, 788 NULL, 789 }; 790 ATTRIBUTE_GROUPS(damon_sysfs_weights); 791 792 static const struct kobj_type damon_sysfs_weights_ktype = { 793 .release = damon_sysfs_weights_release, 794 .sysfs_ops = &kobj_sysfs_ops, 795 .default_groups = damon_sysfs_weights_groups, 796 }; 797 798 /* 799 * quotas directory 800 */ 801 802 struct damon_sysfs_quotas { 803 struct kobject kobj; 804 struct damon_sysfs_weights *weights; 805 unsigned long ms; 806 unsigned long sz; 807 unsigned long reset_interval_ms; 808 }; 809 810 static struct damon_sysfs_quotas *damon_sysfs_quotas_alloc(void) 811 { 812 return kzalloc(sizeof(struct damon_sysfs_quotas), GFP_KERNEL); 813 } 814 815 static int damon_sysfs_quotas_add_dirs(struct damon_sysfs_quotas *quotas) 816 { 817 struct damon_sysfs_weights *weights; 818 int err; 819 820 weights = damon_sysfs_weights_alloc(0, 0, 0); 821 if (!weights) 822 return -ENOMEM; 823 824 err = kobject_init_and_add(&weights->kobj, &damon_sysfs_weights_ktype, 825 "as->kobj, "weights"); 826 if (err) 827 kobject_put(&weights->kobj); 828 else 829 quotas->weights = weights; 830 return err; 831 } 832 833 static void damon_sysfs_quotas_rm_dirs(struct damon_sysfs_quotas *quotas) 834 { 835 kobject_put("as->weights->kobj); 836 } 837 838 static ssize_t ms_show(struct kobject *kobj, struct kobj_attribute *attr, 839 char *buf) 840 { 841 struct damon_sysfs_quotas *quotas = container_of(kobj, 842 struct damon_sysfs_quotas, kobj); 843 844 return sysfs_emit(buf, "%lu\n", quotas->ms); 845 } 846 847 static ssize_t ms_store(struct kobject *kobj, struct kobj_attribute *attr, 848 const char *buf, size_t count) 849 { 850 struct damon_sysfs_quotas *quotas = container_of(kobj, 851 struct damon_sysfs_quotas, kobj); 852 int err = kstrtoul(buf, 0, "as->ms); 853 854 if (err) 855 return -EINVAL; 856 return count; 857 } 858 859 static ssize_t bytes_show(struct kobject *kobj, struct kobj_attribute *attr, 860 char *buf) 861 { 862 struct damon_sysfs_quotas *quotas = container_of(kobj, 863 struct damon_sysfs_quotas, kobj); 864 865 return sysfs_emit(buf, "%lu\n", quotas->sz); 866 } 867 868 static ssize_t bytes_store(struct kobject *kobj, 869 struct kobj_attribute *attr, const char *buf, size_t count) 870 { 871 struct damon_sysfs_quotas *quotas = container_of(kobj, 872 struct damon_sysfs_quotas, kobj); 873 int err = kstrtoul(buf, 0, "as->sz); 874 875 if (err) 876 return -EINVAL; 877 return count; 878 } 879 880 static ssize_t reset_interval_ms_show(struct kobject *kobj, 881 struct kobj_attribute *attr, char *buf) 882 { 883 struct damon_sysfs_quotas *quotas = container_of(kobj, 884 struct damon_sysfs_quotas, kobj); 885 886 return sysfs_emit(buf, "%lu\n", quotas->reset_interval_ms); 887 } 888 889 static ssize_t reset_interval_ms_store(struct kobject *kobj, 890 struct kobj_attribute *attr, const char *buf, size_t count) 891 { 892 struct damon_sysfs_quotas *quotas = container_of(kobj, 893 struct damon_sysfs_quotas, kobj); 894 int err = kstrtoul(buf, 0, "as->reset_interval_ms); 895 896 if (err) 897 return -EINVAL; 898 return count; 899 } 900 901 static void damon_sysfs_quotas_release(struct kobject *kobj) 902 { 903 kfree(container_of(kobj, struct damon_sysfs_quotas, kobj)); 904 } 905 906 static struct kobj_attribute damon_sysfs_quotas_ms_attr = 907 __ATTR_RW_MODE(ms, 0600); 908 909 static struct kobj_attribute damon_sysfs_quotas_sz_attr = 910 __ATTR_RW_MODE(bytes, 0600); 911 912 static struct kobj_attribute damon_sysfs_quotas_reset_interval_ms_attr = 913 __ATTR_RW_MODE(reset_interval_ms, 0600); 914 915 static struct attribute *damon_sysfs_quotas_attrs[] = { 916 &damon_sysfs_quotas_ms_attr.attr, 917 &damon_sysfs_quotas_sz_attr.attr, 918 &damon_sysfs_quotas_reset_interval_ms_attr.attr, 919 NULL, 920 }; 921 ATTRIBUTE_GROUPS(damon_sysfs_quotas); 922 923 static const struct kobj_type damon_sysfs_quotas_ktype = { 924 .release = damon_sysfs_quotas_release, 925 .sysfs_ops = &kobj_sysfs_ops, 926 .default_groups = damon_sysfs_quotas_groups, 927 }; 928 929 /* 930 * access_pattern directory 931 */ 932 933 struct damon_sysfs_access_pattern { 934 struct kobject kobj; 935 struct damon_sysfs_ul_range *sz; 936 struct damon_sysfs_ul_range *nr_accesses; 937 struct damon_sysfs_ul_range *age; 938 }; 939 940 static 941 struct damon_sysfs_access_pattern *damon_sysfs_access_pattern_alloc(void) 942 { 943 struct damon_sysfs_access_pattern *access_pattern = 944 kmalloc(sizeof(*access_pattern), GFP_KERNEL); 945 946 if (!access_pattern) 947 return NULL; 948 access_pattern->kobj = (struct kobject){}; 949 return access_pattern; 950 } 951 952 static int damon_sysfs_access_pattern_add_range_dir( 953 struct damon_sysfs_access_pattern *access_pattern, 954 struct damon_sysfs_ul_range **range_dir_ptr, 955 char *name) 956 { 957 struct damon_sysfs_ul_range *range = damon_sysfs_ul_range_alloc(0, 0); 958 int err; 959 960 if (!range) 961 return -ENOMEM; 962 err = kobject_init_and_add(&range->kobj, &damon_sysfs_ul_range_ktype, 963 &access_pattern->kobj, name); 964 if (err) 965 kobject_put(&range->kobj); 966 else 967 *range_dir_ptr = range; 968 return err; 969 } 970 971 static int damon_sysfs_access_pattern_add_dirs( 972 struct damon_sysfs_access_pattern *access_pattern) 973 { 974 int err; 975 976 err = damon_sysfs_access_pattern_add_range_dir(access_pattern, 977 &access_pattern->sz, "sz"); 978 if (err) 979 goto put_sz_out; 980 981 err = damon_sysfs_access_pattern_add_range_dir(access_pattern, 982 &access_pattern->nr_accesses, "nr_accesses"); 983 if (err) 984 goto put_nr_accesses_sz_out; 985 986 err = damon_sysfs_access_pattern_add_range_dir(access_pattern, 987 &access_pattern->age, "age"); 988 if (err) 989 goto put_age_nr_accesses_sz_out; 990 return 0; 991 992 put_age_nr_accesses_sz_out: 993 kobject_put(&access_pattern->age->kobj); 994 access_pattern->age = NULL; 995 put_nr_accesses_sz_out: 996 kobject_put(&access_pattern->nr_accesses->kobj); 997 access_pattern->nr_accesses = NULL; 998 put_sz_out: 999 kobject_put(&access_pattern->sz->kobj); 1000 access_pattern->sz = NULL; 1001 return err; 1002 } 1003 1004 static void damon_sysfs_access_pattern_rm_dirs( 1005 struct damon_sysfs_access_pattern *access_pattern) 1006 { 1007 kobject_put(&access_pattern->sz->kobj); 1008 kobject_put(&access_pattern->nr_accesses->kobj); 1009 kobject_put(&access_pattern->age->kobj); 1010 } 1011 1012 static void damon_sysfs_access_pattern_release(struct kobject *kobj) 1013 { 1014 kfree(container_of(kobj, struct damon_sysfs_access_pattern, kobj)); 1015 } 1016 1017 static struct attribute *damon_sysfs_access_pattern_attrs[] = { 1018 NULL, 1019 }; 1020 ATTRIBUTE_GROUPS(damon_sysfs_access_pattern); 1021 1022 static const struct kobj_type damon_sysfs_access_pattern_ktype = { 1023 .release = damon_sysfs_access_pattern_release, 1024 .sysfs_ops = &kobj_sysfs_ops, 1025 .default_groups = damon_sysfs_access_pattern_groups, 1026 }; 1027 1028 /* 1029 * scheme directory 1030 */ 1031 1032 struct damon_sysfs_scheme { 1033 struct kobject kobj; 1034 enum damos_action action; 1035 struct damon_sysfs_access_pattern *access_pattern; 1036 struct damon_sysfs_quotas *quotas; 1037 struct damon_sysfs_watermarks *watermarks; 1038 struct damon_sysfs_scheme_filters *filters; 1039 struct damon_sysfs_stats *stats; 1040 struct damon_sysfs_scheme_regions *tried_regions; 1041 }; 1042 1043 /* This should match with enum damos_action */ 1044 static const char * const damon_sysfs_damos_action_strs[] = { 1045 "willneed", 1046 "cold", 1047 "pageout", 1048 "hugepage", 1049 "nohugepage", 1050 "lru_prio", 1051 "lru_deprio", 1052 "stat", 1053 }; 1054 1055 static struct damon_sysfs_scheme *damon_sysfs_scheme_alloc( 1056 enum damos_action action) 1057 { 1058 struct damon_sysfs_scheme *scheme = kmalloc(sizeof(*scheme), 1059 GFP_KERNEL); 1060 1061 if (!scheme) 1062 return NULL; 1063 scheme->kobj = (struct kobject){}; 1064 scheme->action = action; 1065 return scheme; 1066 } 1067 1068 static int damon_sysfs_scheme_set_access_pattern( 1069 struct damon_sysfs_scheme *scheme) 1070 { 1071 struct damon_sysfs_access_pattern *access_pattern; 1072 int err; 1073 1074 access_pattern = damon_sysfs_access_pattern_alloc(); 1075 if (!access_pattern) 1076 return -ENOMEM; 1077 err = kobject_init_and_add(&access_pattern->kobj, 1078 &damon_sysfs_access_pattern_ktype, &scheme->kobj, 1079 "access_pattern"); 1080 if (err) 1081 goto out; 1082 err = damon_sysfs_access_pattern_add_dirs(access_pattern); 1083 if (err) 1084 goto out; 1085 scheme->access_pattern = access_pattern; 1086 return 0; 1087 1088 out: 1089 kobject_put(&access_pattern->kobj); 1090 return err; 1091 } 1092 1093 static int damon_sysfs_scheme_set_quotas(struct damon_sysfs_scheme *scheme) 1094 { 1095 struct damon_sysfs_quotas *quotas = damon_sysfs_quotas_alloc(); 1096 int err; 1097 1098 if (!quotas) 1099 return -ENOMEM; 1100 err = kobject_init_and_add("as->kobj, &damon_sysfs_quotas_ktype, 1101 &scheme->kobj, "quotas"); 1102 if (err) 1103 goto out; 1104 err = damon_sysfs_quotas_add_dirs(quotas); 1105 if (err) 1106 goto out; 1107 scheme->quotas = quotas; 1108 return 0; 1109 1110 out: 1111 kobject_put("as->kobj); 1112 return err; 1113 } 1114 1115 static int damon_sysfs_scheme_set_watermarks(struct damon_sysfs_scheme *scheme) 1116 { 1117 struct damon_sysfs_watermarks *watermarks = 1118 damon_sysfs_watermarks_alloc(DAMOS_WMARK_NONE, 0, 0, 0, 0); 1119 int err; 1120 1121 if (!watermarks) 1122 return -ENOMEM; 1123 err = kobject_init_and_add(&watermarks->kobj, 1124 &damon_sysfs_watermarks_ktype, &scheme->kobj, 1125 "watermarks"); 1126 if (err) 1127 kobject_put(&watermarks->kobj); 1128 else 1129 scheme->watermarks = watermarks; 1130 return err; 1131 } 1132 1133 static int damon_sysfs_scheme_set_filters(struct damon_sysfs_scheme *scheme) 1134 { 1135 struct damon_sysfs_scheme_filters *filters = 1136 damon_sysfs_scheme_filters_alloc(); 1137 int err; 1138 1139 if (!filters) 1140 return -ENOMEM; 1141 err = kobject_init_and_add(&filters->kobj, 1142 &damon_sysfs_scheme_filters_ktype, &scheme->kobj, 1143 "filters"); 1144 if (err) 1145 kobject_put(&filters->kobj); 1146 else 1147 scheme->filters = filters; 1148 return err; 1149 } 1150 1151 static int damon_sysfs_scheme_set_stats(struct damon_sysfs_scheme *scheme) 1152 { 1153 struct damon_sysfs_stats *stats = damon_sysfs_stats_alloc(); 1154 int err; 1155 1156 if (!stats) 1157 return -ENOMEM; 1158 err = kobject_init_and_add(&stats->kobj, &damon_sysfs_stats_ktype, 1159 &scheme->kobj, "stats"); 1160 if (err) 1161 kobject_put(&stats->kobj); 1162 else 1163 scheme->stats = stats; 1164 return err; 1165 } 1166 1167 static int damon_sysfs_scheme_set_tried_regions( 1168 struct damon_sysfs_scheme *scheme) 1169 { 1170 struct damon_sysfs_scheme_regions *tried_regions = 1171 damon_sysfs_scheme_regions_alloc(); 1172 int err; 1173 1174 if (!tried_regions) 1175 return -ENOMEM; 1176 err = kobject_init_and_add(&tried_regions->kobj, 1177 &damon_sysfs_scheme_regions_ktype, &scheme->kobj, 1178 "tried_regions"); 1179 if (err) 1180 kobject_put(&tried_regions->kobj); 1181 else 1182 scheme->tried_regions = tried_regions; 1183 return err; 1184 } 1185 1186 static int damon_sysfs_scheme_add_dirs(struct damon_sysfs_scheme *scheme) 1187 { 1188 int err; 1189 1190 err = damon_sysfs_scheme_set_access_pattern(scheme); 1191 if (err) 1192 return err; 1193 err = damon_sysfs_scheme_set_quotas(scheme); 1194 if (err) 1195 goto put_access_pattern_out; 1196 err = damon_sysfs_scheme_set_watermarks(scheme); 1197 if (err) 1198 goto put_quotas_access_pattern_out; 1199 err = damon_sysfs_scheme_set_filters(scheme); 1200 if (err) 1201 goto put_watermarks_quotas_access_pattern_out; 1202 err = damon_sysfs_scheme_set_stats(scheme); 1203 if (err) 1204 goto put_filters_watermarks_quotas_access_pattern_out; 1205 err = damon_sysfs_scheme_set_tried_regions(scheme); 1206 if (err) 1207 goto put_tried_regions_out; 1208 return 0; 1209 1210 put_tried_regions_out: 1211 kobject_put(&scheme->tried_regions->kobj); 1212 scheme->tried_regions = NULL; 1213 put_filters_watermarks_quotas_access_pattern_out: 1214 kobject_put(&scheme->filters->kobj); 1215 scheme->filters = NULL; 1216 put_watermarks_quotas_access_pattern_out: 1217 kobject_put(&scheme->watermarks->kobj); 1218 scheme->watermarks = NULL; 1219 put_quotas_access_pattern_out: 1220 kobject_put(&scheme->quotas->kobj); 1221 scheme->quotas = NULL; 1222 put_access_pattern_out: 1223 kobject_put(&scheme->access_pattern->kobj); 1224 scheme->access_pattern = NULL; 1225 return err; 1226 } 1227 1228 static void damon_sysfs_scheme_rm_dirs(struct damon_sysfs_scheme *scheme) 1229 { 1230 damon_sysfs_access_pattern_rm_dirs(scheme->access_pattern); 1231 kobject_put(&scheme->access_pattern->kobj); 1232 damon_sysfs_quotas_rm_dirs(scheme->quotas); 1233 kobject_put(&scheme->quotas->kobj); 1234 kobject_put(&scheme->watermarks->kobj); 1235 damon_sysfs_scheme_filters_rm_dirs(scheme->filters); 1236 kobject_put(&scheme->filters->kobj); 1237 kobject_put(&scheme->stats->kobj); 1238 damon_sysfs_scheme_regions_rm_dirs(scheme->tried_regions); 1239 kobject_put(&scheme->tried_regions->kobj); 1240 } 1241 1242 static ssize_t action_show(struct kobject *kobj, struct kobj_attribute *attr, 1243 char *buf) 1244 { 1245 struct damon_sysfs_scheme *scheme = container_of(kobj, 1246 struct damon_sysfs_scheme, kobj); 1247 1248 return sysfs_emit(buf, "%s\n", 1249 damon_sysfs_damos_action_strs[scheme->action]); 1250 } 1251 1252 static ssize_t action_store(struct kobject *kobj, struct kobj_attribute *attr, 1253 const char *buf, size_t count) 1254 { 1255 struct damon_sysfs_scheme *scheme = container_of(kobj, 1256 struct damon_sysfs_scheme, kobj); 1257 enum damos_action action; 1258 1259 for (action = 0; action < NR_DAMOS_ACTIONS; action++) { 1260 if (sysfs_streq(buf, damon_sysfs_damos_action_strs[action])) { 1261 scheme->action = action; 1262 return count; 1263 } 1264 } 1265 return -EINVAL; 1266 } 1267 1268 static void damon_sysfs_scheme_release(struct kobject *kobj) 1269 { 1270 kfree(container_of(kobj, struct damon_sysfs_scheme, kobj)); 1271 } 1272 1273 static struct kobj_attribute damon_sysfs_scheme_action_attr = 1274 __ATTR_RW_MODE(action, 0600); 1275 1276 static struct attribute *damon_sysfs_scheme_attrs[] = { 1277 &damon_sysfs_scheme_action_attr.attr, 1278 NULL, 1279 }; 1280 ATTRIBUTE_GROUPS(damon_sysfs_scheme); 1281 1282 static const struct kobj_type damon_sysfs_scheme_ktype = { 1283 .release = damon_sysfs_scheme_release, 1284 .sysfs_ops = &kobj_sysfs_ops, 1285 .default_groups = damon_sysfs_scheme_groups, 1286 }; 1287 1288 /* 1289 * schemes directory 1290 */ 1291 1292 struct damon_sysfs_schemes *damon_sysfs_schemes_alloc(void) 1293 { 1294 return kzalloc(sizeof(struct damon_sysfs_schemes), GFP_KERNEL); 1295 } 1296 1297 void damon_sysfs_schemes_rm_dirs(struct damon_sysfs_schemes *schemes) 1298 { 1299 struct damon_sysfs_scheme **schemes_arr = schemes->schemes_arr; 1300 int i; 1301 1302 for (i = 0; i < schemes->nr; i++) { 1303 damon_sysfs_scheme_rm_dirs(schemes_arr[i]); 1304 kobject_put(&schemes_arr[i]->kobj); 1305 } 1306 schemes->nr = 0; 1307 kfree(schemes_arr); 1308 schemes->schemes_arr = NULL; 1309 } 1310 1311 static int damon_sysfs_schemes_add_dirs(struct damon_sysfs_schemes *schemes, 1312 int nr_schemes) 1313 { 1314 struct damon_sysfs_scheme **schemes_arr, *scheme; 1315 int err, i; 1316 1317 damon_sysfs_schemes_rm_dirs(schemes); 1318 if (!nr_schemes) 1319 return 0; 1320 1321 schemes_arr = kmalloc_array(nr_schemes, sizeof(*schemes_arr), 1322 GFP_KERNEL | __GFP_NOWARN); 1323 if (!schemes_arr) 1324 return -ENOMEM; 1325 schemes->schemes_arr = schemes_arr; 1326 1327 for (i = 0; i < nr_schemes; i++) { 1328 scheme = damon_sysfs_scheme_alloc(DAMOS_STAT); 1329 if (!scheme) { 1330 damon_sysfs_schemes_rm_dirs(schemes); 1331 return -ENOMEM; 1332 } 1333 1334 err = kobject_init_and_add(&scheme->kobj, 1335 &damon_sysfs_scheme_ktype, &schemes->kobj, 1336 "%d", i); 1337 if (err) 1338 goto out; 1339 err = damon_sysfs_scheme_add_dirs(scheme); 1340 if (err) 1341 goto out; 1342 1343 schemes_arr[i] = scheme; 1344 schemes->nr++; 1345 } 1346 return 0; 1347 1348 out: 1349 damon_sysfs_schemes_rm_dirs(schemes); 1350 kobject_put(&scheme->kobj); 1351 return err; 1352 } 1353 1354 static ssize_t nr_schemes_show(struct kobject *kobj, 1355 struct kobj_attribute *attr, char *buf) 1356 { 1357 struct damon_sysfs_schemes *schemes = container_of(kobj, 1358 struct damon_sysfs_schemes, kobj); 1359 1360 return sysfs_emit(buf, "%d\n", schemes->nr); 1361 } 1362 1363 static ssize_t nr_schemes_store(struct kobject *kobj, 1364 struct kobj_attribute *attr, const char *buf, size_t count) 1365 { 1366 struct damon_sysfs_schemes *schemes; 1367 int nr, err = kstrtoint(buf, 0, &nr); 1368 1369 if (err) 1370 return err; 1371 if (nr < 0) 1372 return -EINVAL; 1373 1374 schemes = container_of(kobj, struct damon_sysfs_schemes, kobj); 1375 1376 if (!mutex_trylock(&damon_sysfs_lock)) 1377 return -EBUSY; 1378 err = damon_sysfs_schemes_add_dirs(schemes, nr); 1379 mutex_unlock(&damon_sysfs_lock); 1380 if (err) 1381 return err; 1382 return count; 1383 } 1384 1385 static void damon_sysfs_schemes_release(struct kobject *kobj) 1386 { 1387 kfree(container_of(kobj, struct damon_sysfs_schemes, kobj)); 1388 } 1389 1390 static struct kobj_attribute damon_sysfs_schemes_nr_attr = 1391 __ATTR_RW_MODE(nr_schemes, 0600); 1392 1393 static struct attribute *damon_sysfs_schemes_attrs[] = { 1394 &damon_sysfs_schemes_nr_attr.attr, 1395 NULL, 1396 }; 1397 ATTRIBUTE_GROUPS(damon_sysfs_schemes); 1398 1399 const struct kobj_type damon_sysfs_schemes_ktype = { 1400 .release = damon_sysfs_schemes_release, 1401 .sysfs_ops = &kobj_sysfs_ops, 1402 .default_groups = damon_sysfs_schemes_groups, 1403 }; 1404 1405 static bool damon_sysfs_memcg_path_eq(struct mem_cgroup *memcg, 1406 char *memcg_path_buf, char *path) 1407 { 1408 #ifdef CONFIG_MEMCG 1409 cgroup_path(memcg->css.cgroup, memcg_path_buf, PATH_MAX); 1410 if (sysfs_streq(memcg_path_buf, path)) 1411 return true; 1412 #endif /* CONFIG_MEMCG */ 1413 return false; 1414 } 1415 1416 static int damon_sysfs_memcg_path_to_id(char *memcg_path, unsigned short *id) 1417 { 1418 struct mem_cgroup *memcg; 1419 char *path; 1420 bool found = false; 1421 1422 if (!memcg_path) 1423 return -EINVAL; 1424 1425 path = kmalloc(sizeof(*path) * PATH_MAX, GFP_KERNEL); 1426 if (!path) 1427 return -ENOMEM; 1428 1429 for (memcg = mem_cgroup_iter(NULL, NULL, NULL); memcg; 1430 memcg = mem_cgroup_iter(NULL, memcg, NULL)) { 1431 /* skip removed memcg */ 1432 if (!mem_cgroup_id(memcg)) 1433 continue; 1434 if (damon_sysfs_memcg_path_eq(memcg, path, memcg_path)) { 1435 *id = mem_cgroup_id(memcg); 1436 found = true; 1437 break; 1438 } 1439 } 1440 1441 kfree(path); 1442 return found ? 0 : -EINVAL; 1443 } 1444 1445 static int damon_sysfs_set_scheme_filters(struct damos *scheme, 1446 struct damon_sysfs_scheme_filters *sysfs_filters) 1447 { 1448 int i; 1449 struct damos_filter *filter, *next; 1450 1451 damos_for_each_filter_safe(filter, next, scheme) 1452 damos_destroy_filter(filter); 1453 1454 for (i = 0; i < sysfs_filters->nr; i++) { 1455 struct damon_sysfs_scheme_filter *sysfs_filter = 1456 sysfs_filters->filters_arr[i]; 1457 struct damos_filter *filter = 1458 damos_new_filter(sysfs_filter->type, 1459 sysfs_filter->matching); 1460 int err; 1461 1462 if (!filter) 1463 return -ENOMEM; 1464 if (filter->type == DAMOS_FILTER_TYPE_MEMCG) { 1465 err = damon_sysfs_memcg_path_to_id( 1466 sysfs_filter->memcg_path, 1467 &filter->memcg_id); 1468 if (err) { 1469 damos_destroy_filter(filter); 1470 return err; 1471 } 1472 } 1473 damos_add_filter(scheme, filter); 1474 } 1475 return 0; 1476 } 1477 1478 static struct damos *damon_sysfs_mk_scheme( 1479 struct damon_sysfs_scheme *sysfs_scheme) 1480 { 1481 struct damon_sysfs_access_pattern *access_pattern = 1482 sysfs_scheme->access_pattern; 1483 struct damon_sysfs_quotas *sysfs_quotas = sysfs_scheme->quotas; 1484 struct damon_sysfs_weights *sysfs_weights = sysfs_quotas->weights; 1485 struct damon_sysfs_watermarks *sysfs_wmarks = sysfs_scheme->watermarks; 1486 struct damon_sysfs_scheme_filters *sysfs_filters = 1487 sysfs_scheme->filters; 1488 struct damos *scheme; 1489 int err; 1490 1491 struct damos_access_pattern pattern = { 1492 .min_sz_region = access_pattern->sz->min, 1493 .max_sz_region = access_pattern->sz->max, 1494 .min_nr_accesses = access_pattern->nr_accesses->min, 1495 .max_nr_accesses = access_pattern->nr_accesses->max, 1496 .min_age_region = access_pattern->age->min, 1497 .max_age_region = access_pattern->age->max, 1498 }; 1499 struct damos_quota quota = { 1500 .ms = sysfs_quotas->ms, 1501 .sz = sysfs_quotas->sz, 1502 .reset_interval = sysfs_quotas->reset_interval_ms, 1503 .weight_sz = sysfs_weights->sz, 1504 .weight_nr_accesses = sysfs_weights->nr_accesses, 1505 .weight_age = sysfs_weights->age, 1506 }; 1507 struct damos_watermarks wmarks = { 1508 .metric = sysfs_wmarks->metric, 1509 .interval = sysfs_wmarks->interval_us, 1510 .high = sysfs_wmarks->high, 1511 .mid = sysfs_wmarks->mid, 1512 .low = sysfs_wmarks->low, 1513 }; 1514 1515 scheme = damon_new_scheme(&pattern, sysfs_scheme->action, "a, 1516 &wmarks); 1517 if (!scheme) 1518 return NULL; 1519 1520 err = damon_sysfs_set_scheme_filters(scheme, sysfs_filters); 1521 if (err) { 1522 damon_destroy_scheme(scheme); 1523 return NULL; 1524 } 1525 return scheme; 1526 } 1527 1528 static void damon_sysfs_update_scheme(struct damos *scheme, 1529 struct damon_sysfs_scheme *sysfs_scheme) 1530 { 1531 struct damon_sysfs_access_pattern *access_pattern = 1532 sysfs_scheme->access_pattern; 1533 struct damon_sysfs_quotas *sysfs_quotas = sysfs_scheme->quotas; 1534 struct damon_sysfs_weights *sysfs_weights = sysfs_quotas->weights; 1535 struct damon_sysfs_watermarks *sysfs_wmarks = sysfs_scheme->watermarks; 1536 int err; 1537 1538 scheme->pattern.min_sz_region = access_pattern->sz->min; 1539 scheme->pattern.max_sz_region = access_pattern->sz->max; 1540 scheme->pattern.min_nr_accesses = access_pattern->nr_accesses->min; 1541 scheme->pattern.max_nr_accesses = access_pattern->nr_accesses->max; 1542 scheme->pattern.min_age_region = access_pattern->age->min; 1543 scheme->pattern.max_age_region = access_pattern->age->max; 1544 1545 scheme->action = sysfs_scheme->action; 1546 1547 scheme->quota.ms = sysfs_quotas->ms; 1548 scheme->quota.sz = sysfs_quotas->sz; 1549 scheme->quota.reset_interval = sysfs_quotas->reset_interval_ms; 1550 scheme->quota.weight_sz = sysfs_weights->sz; 1551 scheme->quota.weight_nr_accesses = sysfs_weights->nr_accesses; 1552 scheme->quota.weight_age = sysfs_weights->age; 1553 1554 scheme->wmarks.metric = sysfs_wmarks->metric; 1555 scheme->wmarks.interval = sysfs_wmarks->interval_us; 1556 scheme->wmarks.high = sysfs_wmarks->high; 1557 scheme->wmarks.mid = sysfs_wmarks->mid; 1558 scheme->wmarks.low = sysfs_wmarks->low; 1559 1560 err = damon_sysfs_set_scheme_filters(scheme, sysfs_scheme->filters); 1561 if (err) 1562 damon_destroy_scheme(scheme); 1563 } 1564 1565 int damon_sysfs_set_schemes(struct damon_ctx *ctx, 1566 struct damon_sysfs_schemes *sysfs_schemes) 1567 { 1568 struct damos *scheme, *next; 1569 int i = 0; 1570 1571 damon_for_each_scheme_safe(scheme, next, ctx) { 1572 if (i < sysfs_schemes->nr) 1573 damon_sysfs_update_scheme(scheme, 1574 sysfs_schemes->schemes_arr[i]); 1575 else 1576 damon_destroy_scheme(scheme); 1577 i++; 1578 } 1579 1580 for (; i < sysfs_schemes->nr; i++) { 1581 struct damos *scheme, *next; 1582 1583 scheme = damon_sysfs_mk_scheme(sysfs_schemes->schemes_arr[i]); 1584 if (!scheme) { 1585 damon_for_each_scheme_safe(scheme, next, ctx) 1586 damon_destroy_scheme(scheme); 1587 return -ENOMEM; 1588 } 1589 damon_add_scheme(ctx, scheme); 1590 } 1591 return 0; 1592 } 1593 1594 void damon_sysfs_schemes_update_stats( 1595 struct damon_sysfs_schemes *sysfs_schemes, 1596 struct damon_ctx *ctx) 1597 { 1598 struct damos *scheme; 1599 int schemes_idx = 0; 1600 1601 damon_for_each_scheme(scheme, ctx) { 1602 struct damon_sysfs_stats *sysfs_stats; 1603 1604 /* user could have removed the scheme sysfs dir */ 1605 if (schemes_idx >= sysfs_schemes->nr) 1606 break; 1607 1608 sysfs_stats = sysfs_schemes->schemes_arr[schemes_idx++]->stats; 1609 sysfs_stats->nr_tried = scheme->stat.nr_tried; 1610 sysfs_stats->sz_tried = scheme->stat.sz_tried; 1611 sysfs_stats->nr_applied = scheme->stat.nr_applied; 1612 sysfs_stats->sz_applied = scheme->stat.sz_applied; 1613 sysfs_stats->qt_exceeds = scheme->stat.qt_exceeds; 1614 } 1615 } 1616 1617 /* 1618 * damon_sysfs_schemes that need to update its schemes regions dir. Protected 1619 * by damon_sysfs_lock 1620 */ 1621 static struct damon_sysfs_schemes *damon_sysfs_schemes_for_damos_callback; 1622 static int damon_sysfs_schemes_region_idx; 1623 1624 /* 1625 * DAMON callback that called before damos apply. While this callback is 1626 * registered, damon_sysfs_lock should be held to ensure the regions 1627 * directories exist. 1628 */ 1629 static int damon_sysfs_before_damos_apply(struct damon_ctx *ctx, 1630 struct damon_target *t, struct damon_region *r, 1631 struct damos *s) 1632 { 1633 struct damos *scheme; 1634 struct damon_sysfs_scheme_regions *sysfs_regions; 1635 struct damon_sysfs_scheme_region *region; 1636 struct damon_sysfs_schemes *sysfs_schemes = 1637 damon_sysfs_schemes_for_damos_callback; 1638 int schemes_idx = 0; 1639 1640 damon_for_each_scheme(scheme, ctx) { 1641 if (scheme == s) 1642 break; 1643 schemes_idx++; 1644 } 1645 1646 /* user could have removed the scheme sysfs dir */ 1647 if (schemes_idx >= sysfs_schemes->nr) 1648 return 0; 1649 1650 sysfs_regions = sysfs_schemes->schemes_arr[schemes_idx]->tried_regions; 1651 region = damon_sysfs_scheme_region_alloc(r); 1652 list_add_tail(®ion->list, &sysfs_regions->regions_list); 1653 sysfs_regions->nr_regions++; 1654 if (kobject_init_and_add(®ion->kobj, 1655 &damon_sysfs_scheme_region_ktype, 1656 &sysfs_regions->kobj, "%d", 1657 damon_sysfs_schemes_region_idx++)) { 1658 kobject_put(®ion->kobj); 1659 } 1660 return 0; 1661 } 1662 1663 /* Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock */ 1664 int damon_sysfs_schemes_clear_regions( 1665 struct damon_sysfs_schemes *sysfs_schemes, 1666 struct damon_ctx *ctx) 1667 { 1668 struct damos *scheme; 1669 int schemes_idx = 0; 1670 1671 damon_for_each_scheme(scheme, ctx) { 1672 struct damon_sysfs_scheme *sysfs_scheme; 1673 1674 /* user could have removed the scheme sysfs dir */ 1675 if (schemes_idx >= sysfs_schemes->nr) 1676 break; 1677 1678 sysfs_scheme = sysfs_schemes->schemes_arr[schemes_idx++]; 1679 damon_sysfs_scheme_regions_rm_dirs( 1680 sysfs_scheme->tried_regions); 1681 } 1682 return 0; 1683 } 1684 1685 /* Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock */ 1686 int damon_sysfs_schemes_update_regions_start( 1687 struct damon_sysfs_schemes *sysfs_schemes, 1688 struct damon_ctx *ctx) 1689 { 1690 damon_sysfs_schemes_clear_regions(sysfs_schemes, ctx); 1691 damon_sysfs_schemes_for_damos_callback = sysfs_schemes; 1692 ctx->callback.before_damos_apply = damon_sysfs_before_damos_apply; 1693 return 0; 1694 } 1695 1696 /* 1697 * Called from damon_sysfs_cmd_request_callback under damon_sysfs_lock. Caller 1698 * should unlock damon_sysfs_lock which held before 1699 * damon_sysfs_schemes_update_regions_start() 1700 */ 1701 int damon_sysfs_schemes_update_regions_stop(struct damon_ctx *ctx) 1702 { 1703 damon_sysfs_schemes_for_damos_callback = NULL; 1704 ctx->callback.before_damos_apply = NULL; 1705 damon_sysfs_schemes_region_idx = 0; 1706 return 0; 1707 } 1708