1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * DAMON Debugfs Interface 4 * 5 * Author: SeongJae Park <sjpark@amazon.de> 6 */ 7 8 #define pr_fmt(fmt) "damon-dbgfs: " fmt 9 10 #include <linux/damon.h> 11 #include <linux/debugfs.h> 12 #include <linux/file.h> 13 #include <linux/mm.h> 14 #include <linux/module.h> 15 #include <linux/page_idle.h> 16 #include <linux/slab.h> 17 18 static struct damon_ctx **dbgfs_ctxs; 19 static int dbgfs_nr_ctxs; 20 static struct dentry **dbgfs_dirs; 21 static DEFINE_MUTEX(damon_dbgfs_lock); 22 23 /* 24 * Returns non-empty string on success, negative error code otherwise. 25 */ 26 static char *user_input_str(const char __user *buf, size_t count, loff_t *ppos) 27 { 28 char *kbuf; 29 ssize_t ret; 30 31 /* We do not accept continuous write */ 32 if (*ppos) 33 return ERR_PTR(-EINVAL); 34 35 kbuf = kmalloc(count + 1, GFP_KERNEL | __GFP_NOWARN); 36 if (!kbuf) 37 return ERR_PTR(-ENOMEM); 38 39 ret = simple_write_to_buffer(kbuf, count + 1, ppos, buf, count); 40 if (ret != count) { 41 kfree(kbuf); 42 return ERR_PTR(-EIO); 43 } 44 kbuf[ret] = '\0'; 45 46 return kbuf; 47 } 48 49 static ssize_t dbgfs_attrs_read(struct file *file, 50 char __user *buf, size_t count, loff_t *ppos) 51 { 52 struct damon_ctx *ctx = file->private_data; 53 char kbuf[128]; 54 int ret; 55 56 mutex_lock(&ctx->kdamond_lock); 57 ret = scnprintf(kbuf, ARRAY_SIZE(kbuf), "%lu %lu %lu %lu %lu\n", 58 ctx->sample_interval, ctx->aggr_interval, 59 ctx->ops_update_interval, ctx->min_nr_regions, 60 ctx->max_nr_regions); 61 mutex_unlock(&ctx->kdamond_lock); 62 63 return simple_read_from_buffer(buf, count, ppos, kbuf, ret); 64 } 65 66 static ssize_t dbgfs_attrs_write(struct file *file, 67 const char __user *buf, size_t count, loff_t *ppos) 68 { 69 struct damon_ctx *ctx = file->private_data; 70 unsigned long s, a, r, minr, maxr; 71 char *kbuf; 72 ssize_t ret; 73 74 kbuf = user_input_str(buf, count, ppos); 75 if (IS_ERR(kbuf)) 76 return PTR_ERR(kbuf); 77 78 if (sscanf(kbuf, "%lu %lu %lu %lu %lu", 79 &s, &a, &r, &minr, &maxr) != 5) { 80 ret = -EINVAL; 81 goto out; 82 } 83 84 mutex_lock(&ctx->kdamond_lock); 85 if (ctx->kdamond) { 86 ret = -EBUSY; 87 goto unlock_out; 88 } 89 90 ret = damon_set_attrs(ctx, s, a, r, minr, maxr); 91 if (!ret) 92 ret = count; 93 unlock_out: 94 mutex_unlock(&ctx->kdamond_lock); 95 out: 96 kfree(kbuf); 97 return ret; 98 } 99 100 static ssize_t sprint_schemes(struct damon_ctx *c, char *buf, ssize_t len) 101 { 102 struct damos *s; 103 int written = 0; 104 int rc; 105 106 damon_for_each_scheme(s, c) { 107 rc = scnprintf(&buf[written], len - written, 108 "%lu %lu %u %u %u %u %d %lu %lu %lu %u %u %u %d %lu %lu %lu %lu %lu %lu %lu %lu %lu\n", 109 s->min_sz_region, s->max_sz_region, 110 s->min_nr_accesses, s->max_nr_accesses, 111 s->min_age_region, s->max_age_region, 112 s->action, 113 s->quota.ms, s->quota.sz, 114 s->quota.reset_interval, 115 s->quota.weight_sz, 116 s->quota.weight_nr_accesses, 117 s->quota.weight_age, 118 s->wmarks.metric, s->wmarks.interval, 119 s->wmarks.high, s->wmarks.mid, s->wmarks.low, 120 s->stat.nr_tried, s->stat.sz_tried, 121 s->stat.nr_applied, s->stat.sz_applied, 122 s->stat.qt_exceeds); 123 if (!rc) 124 return -ENOMEM; 125 126 written += rc; 127 } 128 return written; 129 } 130 131 static ssize_t dbgfs_schemes_read(struct file *file, char __user *buf, 132 size_t count, loff_t *ppos) 133 { 134 struct damon_ctx *ctx = file->private_data; 135 char *kbuf; 136 ssize_t len; 137 138 kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN); 139 if (!kbuf) 140 return -ENOMEM; 141 142 mutex_lock(&ctx->kdamond_lock); 143 len = sprint_schemes(ctx, kbuf, count); 144 mutex_unlock(&ctx->kdamond_lock); 145 if (len < 0) 146 goto out; 147 len = simple_read_from_buffer(buf, count, ppos, kbuf, len); 148 149 out: 150 kfree(kbuf); 151 return len; 152 } 153 154 static void free_schemes_arr(struct damos **schemes, ssize_t nr_schemes) 155 { 156 ssize_t i; 157 158 for (i = 0; i < nr_schemes; i++) 159 kfree(schemes[i]); 160 kfree(schemes); 161 } 162 163 static bool damos_action_valid(int action) 164 { 165 switch (action) { 166 case DAMOS_WILLNEED: 167 case DAMOS_COLD: 168 case DAMOS_PAGEOUT: 169 case DAMOS_HUGEPAGE: 170 case DAMOS_NOHUGEPAGE: 171 case DAMOS_STAT: 172 return true; 173 default: 174 return false; 175 } 176 } 177 178 /* 179 * Converts a string into an array of struct damos pointers 180 * 181 * Returns an array of struct damos pointers that converted if the conversion 182 * success, or NULL otherwise. 183 */ 184 static struct damos **str_to_schemes(const char *str, ssize_t len, 185 ssize_t *nr_schemes) 186 { 187 struct damos *scheme, **schemes; 188 const int max_nr_schemes = 256; 189 int pos = 0, parsed, ret; 190 unsigned long min_sz, max_sz; 191 unsigned int min_nr_a, max_nr_a, min_age, max_age; 192 unsigned int action; 193 194 schemes = kmalloc_array(max_nr_schemes, sizeof(scheme), 195 GFP_KERNEL); 196 if (!schemes) 197 return NULL; 198 199 *nr_schemes = 0; 200 while (pos < len && *nr_schemes < max_nr_schemes) { 201 struct damos_quota quota = {}; 202 struct damos_watermarks wmarks; 203 204 ret = sscanf(&str[pos], 205 "%lu %lu %u %u %u %u %u %lu %lu %lu %u %u %u %u %lu %lu %lu %lu%n", 206 &min_sz, &max_sz, &min_nr_a, &max_nr_a, 207 &min_age, &max_age, &action, "a.ms, 208 "a.sz, "a.reset_interval, 209 "a.weight_sz, "a.weight_nr_accesses, 210 "a.weight_age, &wmarks.metric, 211 &wmarks.interval, &wmarks.high, &wmarks.mid, 212 &wmarks.low, &parsed); 213 if (ret != 18) 214 break; 215 if (!damos_action_valid(action)) 216 goto fail; 217 218 if (min_sz > max_sz || min_nr_a > max_nr_a || min_age > max_age) 219 goto fail; 220 221 if (wmarks.high < wmarks.mid || wmarks.high < wmarks.low || 222 wmarks.mid < wmarks.low) 223 goto fail; 224 225 pos += parsed; 226 scheme = damon_new_scheme(min_sz, max_sz, min_nr_a, max_nr_a, 227 min_age, max_age, action, "a, &wmarks); 228 if (!scheme) 229 goto fail; 230 231 schemes[*nr_schemes] = scheme; 232 *nr_schemes += 1; 233 } 234 return schemes; 235 fail: 236 free_schemes_arr(schemes, *nr_schemes); 237 return NULL; 238 } 239 240 static ssize_t dbgfs_schemes_write(struct file *file, const char __user *buf, 241 size_t count, loff_t *ppos) 242 { 243 struct damon_ctx *ctx = file->private_data; 244 char *kbuf; 245 struct damos **schemes; 246 ssize_t nr_schemes = 0, ret; 247 248 kbuf = user_input_str(buf, count, ppos); 249 if (IS_ERR(kbuf)) 250 return PTR_ERR(kbuf); 251 252 schemes = str_to_schemes(kbuf, count, &nr_schemes); 253 if (!schemes) { 254 ret = -EINVAL; 255 goto out; 256 } 257 258 mutex_lock(&ctx->kdamond_lock); 259 if (ctx->kdamond) { 260 ret = -EBUSY; 261 goto unlock_out; 262 } 263 264 ret = damon_set_schemes(ctx, schemes, nr_schemes); 265 if (!ret) { 266 ret = count; 267 nr_schemes = 0; 268 } 269 270 unlock_out: 271 mutex_unlock(&ctx->kdamond_lock); 272 free_schemes_arr(schemes, nr_schemes); 273 out: 274 kfree(kbuf); 275 return ret; 276 } 277 278 static inline bool target_has_pid(const struct damon_ctx *ctx) 279 { 280 return ctx->ops.id == DAMON_OPS_VADDR; 281 } 282 283 static ssize_t sprint_target_ids(struct damon_ctx *ctx, char *buf, ssize_t len) 284 { 285 struct damon_target *t; 286 int id; 287 int written = 0; 288 int rc; 289 290 damon_for_each_target(t, ctx) { 291 if (target_has_pid(ctx)) 292 /* Show pid numbers to debugfs users */ 293 id = pid_vnr(t->pid); 294 else 295 /* Show 42 for physical address space, just for fun */ 296 id = 42; 297 298 rc = scnprintf(&buf[written], len - written, "%d ", id); 299 if (!rc) 300 return -ENOMEM; 301 written += rc; 302 } 303 if (written) 304 written -= 1; 305 written += scnprintf(&buf[written], len - written, "\n"); 306 return written; 307 } 308 309 static ssize_t dbgfs_target_ids_read(struct file *file, 310 char __user *buf, size_t count, loff_t *ppos) 311 { 312 struct damon_ctx *ctx = file->private_data; 313 ssize_t len; 314 char ids_buf[320]; 315 316 mutex_lock(&ctx->kdamond_lock); 317 len = sprint_target_ids(ctx, ids_buf, 320); 318 mutex_unlock(&ctx->kdamond_lock); 319 if (len < 0) 320 return len; 321 322 return simple_read_from_buffer(buf, count, ppos, ids_buf, len); 323 } 324 325 /* 326 * Converts a string into an integers array 327 * 328 * Returns an array of integers array if the conversion success, or NULL 329 * otherwise. 330 */ 331 static int *str_to_ints(const char *str, ssize_t len, ssize_t *nr_ints) 332 { 333 int *array; 334 const int max_nr_ints = 32; 335 int nr; 336 int pos = 0, parsed, ret; 337 338 *nr_ints = 0; 339 array = kmalloc_array(max_nr_ints, sizeof(*array), GFP_KERNEL); 340 if (!array) 341 return NULL; 342 while (*nr_ints < max_nr_ints && pos < len) { 343 ret = sscanf(&str[pos], "%d%n", &nr, &parsed); 344 pos += parsed; 345 if (ret != 1) 346 break; 347 array[*nr_ints] = nr; 348 *nr_ints += 1; 349 } 350 351 return array; 352 } 353 354 static void dbgfs_put_pids(struct pid **pids, int nr_pids) 355 { 356 int i; 357 358 for (i = 0; i < nr_pids; i++) 359 put_pid(pids[i]); 360 } 361 362 /* 363 * Converts a string into an struct pid pointers array 364 * 365 * Returns an array of struct pid pointers if the conversion success, or NULL 366 * otherwise. 367 */ 368 static struct pid **str_to_pids(const char *str, ssize_t len, ssize_t *nr_pids) 369 { 370 int *ints; 371 ssize_t nr_ints; 372 struct pid **pids; 373 374 *nr_pids = 0; 375 376 ints = str_to_ints(str, len, &nr_ints); 377 if (!ints) 378 return NULL; 379 380 pids = kmalloc_array(nr_ints, sizeof(*pids), GFP_KERNEL); 381 if (!pids) 382 goto out; 383 384 for (; *nr_pids < nr_ints; (*nr_pids)++) { 385 pids[*nr_pids] = find_get_pid(ints[*nr_pids]); 386 if (!pids[*nr_pids]) { 387 dbgfs_put_pids(pids, *nr_pids); 388 kfree(ints); 389 kfree(pids); 390 return NULL; 391 } 392 } 393 394 out: 395 kfree(ints); 396 return pids; 397 } 398 399 /* 400 * dbgfs_set_targets() - Set monitoring targets. 401 * @ctx: monitoring context 402 * @nr_targets: number of targets 403 * @pids: array of target pids (size is same to @nr_targets) 404 * 405 * This function should not be called while the kdamond is running. @pids is 406 * ignored if the context is not configured to have pid in each target. On 407 * failure, reference counts of all pids in @pids are decremented. 408 * 409 * Return: 0 on success, negative error code otherwise. 410 */ 411 static int dbgfs_set_targets(struct damon_ctx *ctx, ssize_t nr_targets, 412 struct pid **pids) 413 { 414 ssize_t i; 415 struct damon_target *t, *next; 416 417 damon_for_each_target_safe(t, next, ctx) { 418 if (target_has_pid(ctx)) 419 put_pid(t->pid); 420 damon_destroy_target(t); 421 } 422 423 for (i = 0; i < nr_targets; i++) { 424 t = damon_new_target(); 425 if (!t) { 426 damon_for_each_target_safe(t, next, ctx) 427 damon_destroy_target(t); 428 if (target_has_pid(ctx)) 429 dbgfs_put_pids(pids, nr_targets); 430 return -ENOMEM; 431 } 432 if (target_has_pid(ctx)) 433 t->pid = pids[i]; 434 damon_add_target(ctx, t); 435 } 436 437 return 0; 438 } 439 440 static ssize_t dbgfs_target_ids_write(struct file *file, 441 const char __user *buf, size_t count, loff_t *ppos) 442 { 443 struct damon_ctx *ctx = file->private_data; 444 bool id_is_pid = true; 445 char *kbuf; 446 struct pid **target_pids = NULL; 447 ssize_t nr_targets; 448 ssize_t ret; 449 450 kbuf = user_input_str(buf, count, ppos); 451 if (IS_ERR(kbuf)) 452 return PTR_ERR(kbuf); 453 454 if (!strncmp(kbuf, "paddr\n", count)) { 455 id_is_pid = false; 456 nr_targets = 1; 457 } 458 459 if (id_is_pid) { 460 target_pids = str_to_pids(kbuf, count, &nr_targets); 461 if (!target_pids) { 462 ret = -ENOMEM; 463 goto out; 464 } 465 } 466 467 mutex_lock(&ctx->kdamond_lock); 468 if (ctx->kdamond) { 469 if (id_is_pid) 470 dbgfs_put_pids(target_pids, nr_targets); 471 ret = -EBUSY; 472 goto unlock_out; 473 } 474 475 /* remove previously set targets */ 476 dbgfs_set_targets(ctx, 0, NULL); 477 if (!nr_targets) { 478 ret = count; 479 goto unlock_out; 480 } 481 482 /* Configure the context for the address space type */ 483 if (id_is_pid) 484 ret = damon_select_ops(ctx, DAMON_OPS_VADDR); 485 else 486 ret = damon_select_ops(ctx, DAMON_OPS_PADDR); 487 if (ret) 488 goto unlock_out; 489 490 ret = dbgfs_set_targets(ctx, nr_targets, target_pids); 491 if (!ret) 492 ret = count; 493 494 unlock_out: 495 mutex_unlock(&ctx->kdamond_lock); 496 kfree(target_pids); 497 out: 498 kfree(kbuf); 499 return ret; 500 } 501 502 static ssize_t sprint_init_regions(struct damon_ctx *c, char *buf, ssize_t len) 503 { 504 struct damon_target *t; 505 struct damon_region *r; 506 int target_idx = 0; 507 int written = 0; 508 int rc; 509 510 damon_for_each_target(t, c) { 511 damon_for_each_region(r, t) { 512 rc = scnprintf(&buf[written], len - written, 513 "%d %lu %lu\n", 514 target_idx, r->ar.start, r->ar.end); 515 if (!rc) 516 return -ENOMEM; 517 written += rc; 518 } 519 target_idx++; 520 } 521 return written; 522 } 523 524 static ssize_t dbgfs_init_regions_read(struct file *file, char __user *buf, 525 size_t count, loff_t *ppos) 526 { 527 struct damon_ctx *ctx = file->private_data; 528 char *kbuf; 529 ssize_t len; 530 531 kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN); 532 if (!kbuf) 533 return -ENOMEM; 534 535 mutex_lock(&ctx->kdamond_lock); 536 if (ctx->kdamond) { 537 mutex_unlock(&ctx->kdamond_lock); 538 len = -EBUSY; 539 goto out; 540 } 541 542 len = sprint_init_regions(ctx, kbuf, count); 543 mutex_unlock(&ctx->kdamond_lock); 544 if (len < 0) 545 goto out; 546 len = simple_read_from_buffer(buf, count, ppos, kbuf, len); 547 548 out: 549 kfree(kbuf); 550 return len; 551 } 552 553 static int add_init_region(struct damon_ctx *c, int target_idx, 554 struct damon_addr_range *ar) 555 { 556 struct damon_target *t; 557 struct damon_region *r, *prev; 558 unsigned long idx = 0; 559 int rc = -EINVAL; 560 561 if (ar->start >= ar->end) 562 return -EINVAL; 563 564 damon_for_each_target(t, c) { 565 if (idx++ == target_idx) { 566 r = damon_new_region(ar->start, ar->end); 567 if (!r) 568 return -ENOMEM; 569 damon_add_region(r, t); 570 if (damon_nr_regions(t) > 1) { 571 prev = damon_prev_region(r); 572 if (prev->ar.end > r->ar.start) { 573 damon_destroy_region(r, t); 574 return -EINVAL; 575 } 576 } 577 rc = 0; 578 } 579 } 580 return rc; 581 } 582 583 static int set_init_regions(struct damon_ctx *c, const char *str, ssize_t len) 584 { 585 struct damon_target *t; 586 struct damon_region *r, *next; 587 int pos = 0, parsed, ret; 588 int target_idx; 589 struct damon_addr_range ar; 590 int err; 591 592 damon_for_each_target(t, c) { 593 damon_for_each_region_safe(r, next, t) 594 damon_destroy_region(r, t); 595 } 596 597 while (pos < len) { 598 ret = sscanf(&str[pos], "%d %lu %lu%n", 599 &target_idx, &ar.start, &ar.end, &parsed); 600 if (ret != 3) 601 break; 602 err = add_init_region(c, target_idx, &ar); 603 if (err) 604 goto fail; 605 pos += parsed; 606 } 607 608 return 0; 609 610 fail: 611 damon_for_each_target(t, c) { 612 damon_for_each_region_safe(r, next, t) 613 damon_destroy_region(r, t); 614 } 615 return err; 616 } 617 618 static ssize_t dbgfs_init_regions_write(struct file *file, 619 const char __user *buf, size_t count, 620 loff_t *ppos) 621 { 622 struct damon_ctx *ctx = file->private_data; 623 char *kbuf; 624 ssize_t ret = count; 625 int err; 626 627 kbuf = user_input_str(buf, count, ppos); 628 if (IS_ERR(kbuf)) 629 return PTR_ERR(kbuf); 630 631 mutex_lock(&ctx->kdamond_lock); 632 if (ctx->kdamond) { 633 ret = -EBUSY; 634 goto unlock_out; 635 } 636 637 err = set_init_regions(ctx, kbuf, ret); 638 if (err) 639 ret = err; 640 641 unlock_out: 642 mutex_unlock(&ctx->kdamond_lock); 643 kfree(kbuf); 644 return ret; 645 } 646 647 static ssize_t dbgfs_kdamond_pid_read(struct file *file, 648 char __user *buf, size_t count, loff_t *ppos) 649 { 650 struct damon_ctx *ctx = file->private_data; 651 char *kbuf; 652 ssize_t len; 653 654 kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN); 655 if (!kbuf) 656 return -ENOMEM; 657 658 mutex_lock(&ctx->kdamond_lock); 659 if (ctx->kdamond) 660 len = scnprintf(kbuf, count, "%d\n", ctx->kdamond->pid); 661 else 662 len = scnprintf(kbuf, count, "none\n"); 663 mutex_unlock(&ctx->kdamond_lock); 664 if (!len) 665 goto out; 666 len = simple_read_from_buffer(buf, count, ppos, kbuf, len); 667 668 out: 669 kfree(kbuf); 670 return len; 671 } 672 673 static int damon_dbgfs_open(struct inode *inode, struct file *file) 674 { 675 file->private_data = inode->i_private; 676 677 return nonseekable_open(inode, file); 678 } 679 680 static const struct file_operations attrs_fops = { 681 .open = damon_dbgfs_open, 682 .read = dbgfs_attrs_read, 683 .write = dbgfs_attrs_write, 684 }; 685 686 static const struct file_operations schemes_fops = { 687 .open = damon_dbgfs_open, 688 .read = dbgfs_schemes_read, 689 .write = dbgfs_schemes_write, 690 }; 691 692 static const struct file_operations target_ids_fops = { 693 .open = damon_dbgfs_open, 694 .read = dbgfs_target_ids_read, 695 .write = dbgfs_target_ids_write, 696 }; 697 698 static const struct file_operations init_regions_fops = { 699 .open = damon_dbgfs_open, 700 .read = dbgfs_init_regions_read, 701 .write = dbgfs_init_regions_write, 702 }; 703 704 static const struct file_operations kdamond_pid_fops = { 705 .open = damon_dbgfs_open, 706 .read = dbgfs_kdamond_pid_read, 707 }; 708 709 static void dbgfs_fill_ctx_dir(struct dentry *dir, struct damon_ctx *ctx) 710 { 711 const char * const file_names[] = {"attrs", "schemes", "target_ids", 712 "init_regions", "kdamond_pid"}; 713 const struct file_operations *fops[] = {&attrs_fops, &schemes_fops, 714 &target_ids_fops, &init_regions_fops, &kdamond_pid_fops}; 715 int i; 716 717 for (i = 0; i < ARRAY_SIZE(file_names); i++) 718 debugfs_create_file(file_names[i], 0600, dir, ctx, fops[i]); 719 } 720 721 static void dbgfs_before_terminate(struct damon_ctx *ctx) 722 { 723 struct damon_target *t, *next; 724 725 if (!target_has_pid(ctx)) 726 return; 727 728 mutex_lock(&ctx->kdamond_lock); 729 damon_for_each_target_safe(t, next, ctx) { 730 put_pid(t->pid); 731 damon_destroy_target(t); 732 } 733 mutex_unlock(&ctx->kdamond_lock); 734 } 735 736 static struct damon_ctx *dbgfs_new_ctx(void) 737 { 738 struct damon_ctx *ctx; 739 740 ctx = damon_new_ctx(); 741 if (!ctx) 742 return NULL; 743 744 if (damon_select_ops(ctx, DAMON_OPS_VADDR) && 745 damon_select_ops(ctx, DAMON_OPS_PADDR)) { 746 damon_destroy_ctx(ctx); 747 return NULL; 748 } 749 ctx->callback.before_terminate = dbgfs_before_terminate; 750 return ctx; 751 } 752 753 static void dbgfs_destroy_ctx(struct damon_ctx *ctx) 754 { 755 damon_destroy_ctx(ctx); 756 } 757 758 /* 759 * Make a context of @name and create a debugfs directory for it. 760 * 761 * This function should be called while holding damon_dbgfs_lock. 762 * 763 * Returns 0 on success, negative error code otherwise. 764 */ 765 static int dbgfs_mk_context(char *name) 766 { 767 struct dentry *root, **new_dirs, *new_dir; 768 struct damon_ctx **new_ctxs, *new_ctx; 769 770 if (damon_nr_running_ctxs()) 771 return -EBUSY; 772 773 new_ctxs = krealloc(dbgfs_ctxs, sizeof(*dbgfs_ctxs) * 774 (dbgfs_nr_ctxs + 1), GFP_KERNEL); 775 if (!new_ctxs) 776 return -ENOMEM; 777 dbgfs_ctxs = new_ctxs; 778 779 new_dirs = krealloc(dbgfs_dirs, sizeof(*dbgfs_dirs) * 780 (dbgfs_nr_ctxs + 1), GFP_KERNEL); 781 if (!new_dirs) 782 return -ENOMEM; 783 dbgfs_dirs = new_dirs; 784 785 root = dbgfs_dirs[0]; 786 if (!root) 787 return -ENOENT; 788 789 new_dir = debugfs_create_dir(name, root); 790 dbgfs_dirs[dbgfs_nr_ctxs] = new_dir; 791 792 new_ctx = dbgfs_new_ctx(); 793 if (!new_ctx) { 794 debugfs_remove(new_dir); 795 dbgfs_dirs[dbgfs_nr_ctxs] = NULL; 796 return -ENOMEM; 797 } 798 799 dbgfs_ctxs[dbgfs_nr_ctxs] = new_ctx; 800 dbgfs_fill_ctx_dir(dbgfs_dirs[dbgfs_nr_ctxs], 801 dbgfs_ctxs[dbgfs_nr_ctxs]); 802 dbgfs_nr_ctxs++; 803 804 return 0; 805 } 806 807 static ssize_t dbgfs_mk_context_write(struct file *file, 808 const char __user *buf, size_t count, loff_t *ppos) 809 { 810 char *kbuf; 811 char *ctx_name; 812 ssize_t ret; 813 814 kbuf = user_input_str(buf, count, ppos); 815 if (IS_ERR(kbuf)) 816 return PTR_ERR(kbuf); 817 ctx_name = kmalloc(count + 1, GFP_KERNEL); 818 if (!ctx_name) { 819 kfree(kbuf); 820 return -ENOMEM; 821 } 822 823 /* Trim white space */ 824 if (sscanf(kbuf, "%s", ctx_name) != 1) { 825 ret = -EINVAL; 826 goto out; 827 } 828 829 mutex_lock(&damon_dbgfs_lock); 830 ret = dbgfs_mk_context(ctx_name); 831 if (!ret) 832 ret = count; 833 mutex_unlock(&damon_dbgfs_lock); 834 835 out: 836 kfree(kbuf); 837 kfree(ctx_name); 838 return ret; 839 } 840 841 /* 842 * Remove a context of @name and its debugfs directory. 843 * 844 * This function should be called while holding damon_dbgfs_lock. 845 * 846 * Return 0 on success, negative error code otherwise. 847 */ 848 static int dbgfs_rm_context(char *name) 849 { 850 struct dentry *root, *dir, **new_dirs; 851 struct damon_ctx **new_ctxs; 852 int i, j; 853 854 if (damon_nr_running_ctxs()) 855 return -EBUSY; 856 857 root = dbgfs_dirs[0]; 858 if (!root) 859 return -ENOENT; 860 861 dir = debugfs_lookup(name, root); 862 if (!dir) 863 return -ENOENT; 864 865 new_dirs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_dirs), 866 GFP_KERNEL); 867 if (!new_dirs) 868 return -ENOMEM; 869 870 new_ctxs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_ctxs), 871 GFP_KERNEL); 872 if (!new_ctxs) { 873 kfree(new_dirs); 874 return -ENOMEM; 875 } 876 877 for (i = 0, j = 0; i < dbgfs_nr_ctxs; i++) { 878 if (dbgfs_dirs[i] == dir) { 879 debugfs_remove(dbgfs_dirs[i]); 880 dbgfs_destroy_ctx(dbgfs_ctxs[i]); 881 continue; 882 } 883 new_dirs[j] = dbgfs_dirs[i]; 884 new_ctxs[j++] = dbgfs_ctxs[i]; 885 } 886 887 kfree(dbgfs_dirs); 888 kfree(dbgfs_ctxs); 889 890 dbgfs_dirs = new_dirs; 891 dbgfs_ctxs = new_ctxs; 892 dbgfs_nr_ctxs--; 893 894 return 0; 895 } 896 897 static ssize_t dbgfs_rm_context_write(struct file *file, 898 const char __user *buf, size_t count, loff_t *ppos) 899 { 900 char *kbuf; 901 ssize_t ret; 902 char *ctx_name; 903 904 kbuf = user_input_str(buf, count, ppos); 905 if (IS_ERR(kbuf)) 906 return PTR_ERR(kbuf); 907 ctx_name = kmalloc(count + 1, GFP_KERNEL); 908 if (!ctx_name) { 909 kfree(kbuf); 910 return -ENOMEM; 911 } 912 913 /* Trim white space */ 914 if (sscanf(kbuf, "%s", ctx_name) != 1) { 915 ret = -EINVAL; 916 goto out; 917 } 918 919 mutex_lock(&damon_dbgfs_lock); 920 ret = dbgfs_rm_context(ctx_name); 921 if (!ret) 922 ret = count; 923 mutex_unlock(&damon_dbgfs_lock); 924 925 out: 926 kfree(kbuf); 927 kfree(ctx_name); 928 return ret; 929 } 930 931 static ssize_t dbgfs_monitor_on_read(struct file *file, 932 char __user *buf, size_t count, loff_t *ppos) 933 { 934 char monitor_on_buf[5]; 935 bool monitor_on = damon_nr_running_ctxs() != 0; 936 int len; 937 938 len = scnprintf(monitor_on_buf, 5, monitor_on ? "on\n" : "off\n"); 939 940 return simple_read_from_buffer(buf, count, ppos, monitor_on_buf, len); 941 } 942 943 static ssize_t dbgfs_monitor_on_write(struct file *file, 944 const char __user *buf, size_t count, loff_t *ppos) 945 { 946 ssize_t ret; 947 char *kbuf; 948 949 kbuf = user_input_str(buf, count, ppos); 950 if (IS_ERR(kbuf)) 951 return PTR_ERR(kbuf); 952 953 /* Remove white space */ 954 if (sscanf(kbuf, "%s", kbuf) != 1) { 955 kfree(kbuf); 956 return -EINVAL; 957 } 958 959 mutex_lock(&damon_dbgfs_lock); 960 if (!strncmp(kbuf, "on", count)) { 961 int i; 962 963 for (i = 0; i < dbgfs_nr_ctxs; i++) { 964 if (damon_targets_empty(dbgfs_ctxs[i])) { 965 kfree(kbuf); 966 mutex_unlock(&damon_dbgfs_lock); 967 return -EINVAL; 968 } 969 } 970 ret = damon_start(dbgfs_ctxs, dbgfs_nr_ctxs, true); 971 } else if (!strncmp(kbuf, "off", count)) { 972 ret = damon_stop(dbgfs_ctxs, dbgfs_nr_ctxs); 973 } else { 974 ret = -EINVAL; 975 } 976 mutex_unlock(&damon_dbgfs_lock); 977 978 if (!ret) 979 ret = count; 980 kfree(kbuf); 981 return ret; 982 } 983 984 static const struct file_operations mk_contexts_fops = { 985 .write = dbgfs_mk_context_write, 986 }; 987 988 static const struct file_operations rm_contexts_fops = { 989 .write = dbgfs_rm_context_write, 990 }; 991 992 static const struct file_operations monitor_on_fops = { 993 .read = dbgfs_monitor_on_read, 994 .write = dbgfs_monitor_on_write, 995 }; 996 997 static int __init __damon_dbgfs_init(void) 998 { 999 struct dentry *dbgfs_root; 1000 const char * const file_names[] = {"mk_contexts", "rm_contexts", 1001 "monitor_on"}; 1002 const struct file_operations *fops[] = {&mk_contexts_fops, 1003 &rm_contexts_fops, &monitor_on_fops}; 1004 int i; 1005 1006 dbgfs_root = debugfs_create_dir("damon", NULL); 1007 1008 for (i = 0; i < ARRAY_SIZE(file_names); i++) 1009 debugfs_create_file(file_names[i], 0600, dbgfs_root, NULL, 1010 fops[i]); 1011 dbgfs_fill_ctx_dir(dbgfs_root, dbgfs_ctxs[0]); 1012 1013 dbgfs_dirs = kmalloc_array(1, sizeof(dbgfs_root), GFP_KERNEL); 1014 if (!dbgfs_dirs) { 1015 debugfs_remove(dbgfs_root); 1016 return -ENOMEM; 1017 } 1018 dbgfs_dirs[0] = dbgfs_root; 1019 1020 return 0; 1021 } 1022 1023 /* 1024 * Functions for the initialization 1025 */ 1026 1027 static int __init damon_dbgfs_init(void) 1028 { 1029 int rc = -ENOMEM; 1030 1031 mutex_lock(&damon_dbgfs_lock); 1032 dbgfs_ctxs = kmalloc(sizeof(*dbgfs_ctxs), GFP_KERNEL); 1033 if (!dbgfs_ctxs) 1034 goto out; 1035 dbgfs_ctxs[0] = dbgfs_new_ctx(); 1036 if (!dbgfs_ctxs[0]) { 1037 kfree(dbgfs_ctxs); 1038 goto out; 1039 } 1040 dbgfs_nr_ctxs = 1; 1041 1042 rc = __damon_dbgfs_init(); 1043 if (rc) { 1044 kfree(dbgfs_ctxs[0]); 1045 kfree(dbgfs_ctxs); 1046 pr_err("%s: dbgfs init failed\n", __func__); 1047 } 1048 1049 out: 1050 mutex_unlock(&damon_dbgfs_lock); 1051 return rc; 1052 } 1053 1054 module_init(damon_dbgfs_init); 1055 1056 #include "dbgfs-test.h" 1057