1 // SPDX-License-Identifier: GPL-2.0
3 * DAMON Debugfs Interface
5 * Author: SeongJae Park <sjpark@amazon.de>
8 #define pr_fmt(fmt) "damon-dbgfs: " fmt
10 #include <linux/damon.h>
11 #include <linux/debugfs.h>
12 #include <linux/file.h>
14 #include <linux/module.h>
15 #include <linux/page_idle.h>
16 #include <linux/slab.h>
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);
24 * Returns non-empty string on success, negative error code otherwise.
26 static char *user_input_str(const char __user *buf, size_t count, loff_t *ppos)
31 /* We do not accept continuous write */
33 return ERR_PTR(-EINVAL);
35 kbuf = kmalloc(count + 1, GFP_KERNEL | __GFP_NOWARN);
37 return ERR_PTR(-ENOMEM);
39 ret = simple_write_to_buffer(kbuf, count + 1, ppos, buf, count);
49 static ssize_t dbgfs_attrs_read(struct file *file,
50 char __user *buf, size_t count, loff_t *ppos)
52 struct damon_ctx *ctx = file->private_data;
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->primitive_update_interval, ctx->min_nr_regions,
61 mutex_unlock(&ctx->kdamond_lock);
63 return simple_read_from_buffer(buf, count, ppos, kbuf, ret);
66 static ssize_t dbgfs_attrs_write(struct file *file,
67 const char __user *buf, size_t count, loff_t *ppos)
69 struct damon_ctx *ctx = file->private_data;
70 unsigned long s, a, r, minr, maxr;
74 kbuf = user_input_str(buf, count, ppos);
78 if (sscanf(kbuf, "%lu %lu %lu %lu %lu",
79 &s, &a, &r, &minr, &maxr) != 5) {
84 mutex_lock(&ctx->kdamond_lock);
90 ret = damon_set_attrs(ctx, s, a, r, minr, maxr);
94 mutex_unlock(&ctx->kdamond_lock);
100 static ssize_t sprint_schemes(struct damon_ctx *c, char *buf, ssize_t len)
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,
113 s->quota.ms, s->quota.sz,
114 s->quota.reset_interval,
116 s->quota.weight_nr_accesses,
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,
131 static ssize_t dbgfs_schemes_read(struct file *file, char __user *buf,
132 size_t count, loff_t *ppos)
134 struct damon_ctx *ctx = file->private_data;
138 kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN);
142 mutex_lock(&ctx->kdamond_lock);
143 len = sprint_schemes(ctx, kbuf, count);
144 mutex_unlock(&ctx->kdamond_lock);
147 len = simple_read_from_buffer(buf, count, ppos, kbuf, len);
154 static void free_schemes_arr(struct damos **schemes, ssize_t nr_schemes)
158 for (i = 0; i < nr_schemes; i++)
163 static bool damos_action_valid(int action)
170 case DAMOS_NOHUGEPAGE:
179 * Converts a string into an array of struct damos pointers
181 * Returns an array of struct damos pointers that converted if the conversion
182 * success, or NULL otherwise.
184 static struct damos **str_to_schemes(const char *str, ssize_t len,
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;
194 schemes = kmalloc_array(max_nr_schemes, sizeof(scheme),
200 while (pos < len && *nr_schemes < max_nr_schemes) {
201 struct damos_quota quota = {};
202 struct damos_watermarks wmarks;
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);
215 if (!damos_action_valid(action))
218 if (min_sz > max_sz || min_nr_a > max_nr_a || min_age > max_age)
221 if (wmarks.high < wmarks.mid || wmarks.high < wmarks.low ||
222 wmarks.mid < wmarks.low)
226 scheme = damon_new_scheme(min_sz, max_sz, min_nr_a, max_nr_a,
227 min_age, max_age, action, "a, &wmarks);
231 schemes[*nr_schemes] = scheme;
236 free_schemes_arr(schemes, *nr_schemes);
240 static ssize_t dbgfs_schemes_write(struct file *file, const char __user *buf,
241 size_t count, loff_t *ppos)
243 struct damon_ctx *ctx = file->private_data;
245 struct damos **schemes;
246 ssize_t nr_schemes = 0, ret;
248 kbuf = user_input_str(buf, count, ppos);
250 return PTR_ERR(kbuf);
252 schemes = str_to_schemes(kbuf, count, &nr_schemes);
258 mutex_lock(&ctx->kdamond_lock);
264 ret = damon_set_schemes(ctx, schemes, nr_schemes);
271 mutex_unlock(&ctx->kdamond_lock);
272 free_schemes_arr(schemes, nr_schemes);
278 static inline bool targetid_is_pid(const struct damon_ctx *ctx)
280 return ctx->primitive.target_valid == damon_va_target_valid;
283 static ssize_t sprint_target_ids(struct damon_ctx *ctx, char *buf, ssize_t len)
285 struct damon_target *t;
290 damon_for_each_target(t, ctx) {
292 if (targetid_is_pid(ctx))
293 /* Show pid numbers to debugfs users */
294 id = (unsigned long)pid_vnr((struct pid *)id);
296 rc = scnprintf(&buf[written], len - written, "%lu ", id);
303 written += scnprintf(&buf[written], len - written, "\n");
307 static ssize_t dbgfs_target_ids_read(struct file *file,
308 char __user *buf, size_t count, loff_t *ppos)
310 struct damon_ctx *ctx = file->private_data;
314 mutex_lock(&ctx->kdamond_lock);
315 len = sprint_target_ids(ctx, ids_buf, 320);
316 mutex_unlock(&ctx->kdamond_lock);
320 return simple_read_from_buffer(buf, count, ppos, ids_buf, len);
324 * Converts a string into an array of unsigned long integers
326 * Returns an array of unsigned long integers if the conversion success, or
329 static unsigned long *str_to_target_ids(const char *str, ssize_t len,
333 const int max_nr_ids = 32;
335 int pos = 0, parsed, ret;
338 ids = kmalloc_array(max_nr_ids, sizeof(id), GFP_KERNEL);
341 while (*nr_ids < max_nr_ids && pos < len) {
342 ret = sscanf(&str[pos], "%lu%n", &id, &parsed);
353 static void dbgfs_put_pids(unsigned long *ids, int nr_ids)
357 for (i = 0; i < nr_ids; i++)
358 put_pid((struct pid *)ids[i]);
361 static ssize_t dbgfs_target_ids_write(struct file *file,
362 const char __user *buf, size_t count, loff_t *ppos)
364 struct damon_ctx *ctx = file->private_data;
365 struct damon_target *t, *next_t;
366 bool id_is_pid = true;
368 unsigned long *targets;
373 kbuf = user_input_str(buf, count, ppos);
375 return PTR_ERR(kbuf);
377 if (!strncmp(kbuf, "paddr\n", count)) {
379 /* target id is meaningless here, but we set it just for fun */
380 scnprintf(kbuf, count, "42 ");
383 targets = str_to_target_ids(kbuf, count, &nr_targets);
390 for (i = 0; i < nr_targets; i++) {
391 targets[i] = (unsigned long)find_get_pid(
394 dbgfs_put_pids(targets, i);
396 goto free_targets_out;
401 mutex_lock(&ctx->kdamond_lock);
404 dbgfs_put_pids(targets, nr_targets);
409 /* remove previously set targets */
410 damon_for_each_target_safe(t, next_t, ctx) {
411 if (targetid_is_pid(ctx))
412 put_pid((struct pid *)t->id);
413 damon_destroy_target(t);
416 /* Configure the context for the address space type */
418 damon_va_set_primitives(ctx);
420 damon_pa_set_primitives(ctx);
422 ret = damon_set_targets(ctx, targets, nr_targets);
425 dbgfs_put_pids(targets, nr_targets);
431 mutex_unlock(&ctx->kdamond_lock);
439 static ssize_t sprint_init_regions(struct damon_ctx *c, char *buf, ssize_t len)
441 struct damon_target *t;
442 struct damon_region *r;
447 damon_for_each_target(t, c) {
448 damon_for_each_region(r, t) {
449 rc = scnprintf(&buf[written], len - written,
451 target_idx, r->ar.start, r->ar.end);
461 static ssize_t dbgfs_init_regions_read(struct file *file, char __user *buf,
462 size_t count, loff_t *ppos)
464 struct damon_ctx *ctx = file->private_data;
468 kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN);
472 mutex_lock(&ctx->kdamond_lock);
474 mutex_unlock(&ctx->kdamond_lock);
479 len = sprint_init_regions(ctx, kbuf, count);
480 mutex_unlock(&ctx->kdamond_lock);
483 len = simple_read_from_buffer(buf, count, ppos, kbuf, len);
490 static int add_init_region(struct damon_ctx *c, int target_idx,
491 struct damon_addr_range *ar)
493 struct damon_target *t;
494 struct damon_region *r, *prev;
495 unsigned long idx = 0;
498 if (ar->start >= ar->end)
501 damon_for_each_target(t, c) {
502 if (idx++ == target_idx) {
503 r = damon_new_region(ar->start, ar->end);
506 damon_add_region(r, t);
507 if (damon_nr_regions(t) > 1) {
508 prev = damon_prev_region(r);
509 if (prev->ar.end > r->ar.start) {
510 damon_destroy_region(r, t);
520 static int set_init_regions(struct damon_ctx *c, const char *str, ssize_t len)
522 struct damon_target *t;
523 struct damon_region *r, *next;
524 int pos = 0, parsed, ret;
526 struct damon_addr_range ar;
529 damon_for_each_target(t, c) {
530 damon_for_each_region_safe(r, next, t)
531 damon_destroy_region(r, t);
535 ret = sscanf(&str[pos], "%d %lu %lu%n",
536 &target_idx, &ar.start, &ar.end, &parsed);
539 err = add_init_region(c, target_idx, &ar);
548 damon_for_each_target(t, c) {
549 damon_for_each_region_safe(r, next, t)
550 damon_destroy_region(r, t);
555 static ssize_t dbgfs_init_regions_write(struct file *file,
556 const char __user *buf, size_t count,
559 struct damon_ctx *ctx = file->private_data;
564 kbuf = user_input_str(buf, count, ppos);
566 return PTR_ERR(kbuf);
568 mutex_lock(&ctx->kdamond_lock);
574 err = set_init_regions(ctx, kbuf, ret);
579 mutex_unlock(&ctx->kdamond_lock);
584 static ssize_t dbgfs_kdamond_pid_read(struct file *file,
585 char __user *buf, size_t count, loff_t *ppos)
587 struct damon_ctx *ctx = file->private_data;
591 kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN);
595 mutex_lock(&ctx->kdamond_lock);
597 len = scnprintf(kbuf, count, "%d\n", ctx->kdamond->pid);
599 len = scnprintf(kbuf, count, "none\n");
600 mutex_unlock(&ctx->kdamond_lock);
603 len = simple_read_from_buffer(buf, count, ppos, kbuf, len);
610 static int damon_dbgfs_open(struct inode *inode, struct file *file)
612 file->private_data = inode->i_private;
614 return nonseekable_open(inode, file);
617 static const struct file_operations attrs_fops = {
618 .open = damon_dbgfs_open,
619 .read = dbgfs_attrs_read,
620 .write = dbgfs_attrs_write,
623 static const struct file_operations schemes_fops = {
624 .open = damon_dbgfs_open,
625 .read = dbgfs_schemes_read,
626 .write = dbgfs_schemes_write,
629 static const struct file_operations target_ids_fops = {
630 .open = damon_dbgfs_open,
631 .read = dbgfs_target_ids_read,
632 .write = dbgfs_target_ids_write,
635 static const struct file_operations init_regions_fops = {
636 .open = damon_dbgfs_open,
637 .read = dbgfs_init_regions_read,
638 .write = dbgfs_init_regions_write,
641 static const struct file_operations kdamond_pid_fops = {
642 .open = damon_dbgfs_open,
643 .read = dbgfs_kdamond_pid_read,
646 static void dbgfs_fill_ctx_dir(struct dentry *dir, struct damon_ctx *ctx)
648 const char * const file_names[] = {"attrs", "schemes", "target_ids",
649 "init_regions", "kdamond_pid"};
650 const struct file_operations *fops[] = {&attrs_fops, &schemes_fops,
651 &target_ids_fops, &init_regions_fops, &kdamond_pid_fops};
654 for (i = 0; i < ARRAY_SIZE(file_names); i++)
655 debugfs_create_file(file_names[i], 0600, dir, ctx, fops[i]);
658 static void dbgfs_before_terminate(struct damon_ctx *ctx)
660 struct damon_target *t, *next;
662 if (!targetid_is_pid(ctx))
665 mutex_lock(&ctx->kdamond_lock);
666 damon_for_each_target_safe(t, next, ctx) {
667 put_pid((struct pid *)t->id);
668 damon_destroy_target(t);
670 mutex_unlock(&ctx->kdamond_lock);
673 static struct damon_ctx *dbgfs_new_ctx(void)
675 struct damon_ctx *ctx;
677 ctx = damon_new_ctx();
681 damon_va_set_primitives(ctx);
682 ctx->callback.before_terminate = dbgfs_before_terminate;
686 static void dbgfs_destroy_ctx(struct damon_ctx *ctx)
688 damon_destroy_ctx(ctx);
692 * Make a context of @name and create a debugfs directory for it.
694 * This function should be called while holding damon_dbgfs_lock.
696 * Returns 0 on success, negative error code otherwise.
698 static int dbgfs_mk_context(char *name)
700 struct dentry *root, **new_dirs, *new_dir;
701 struct damon_ctx **new_ctxs, *new_ctx;
703 if (damon_nr_running_ctxs())
706 new_ctxs = krealloc(dbgfs_ctxs, sizeof(*dbgfs_ctxs) *
707 (dbgfs_nr_ctxs + 1), GFP_KERNEL);
710 dbgfs_ctxs = new_ctxs;
712 new_dirs = krealloc(dbgfs_dirs, sizeof(*dbgfs_dirs) *
713 (dbgfs_nr_ctxs + 1), GFP_KERNEL);
716 dbgfs_dirs = new_dirs;
718 root = dbgfs_dirs[0];
722 new_dir = debugfs_create_dir(name, root);
723 dbgfs_dirs[dbgfs_nr_ctxs] = new_dir;
725 new_ctx = dbgfs_new_ctx();
727 debugfs_remove(new_dir);
728 dbgfs_dirs[dbgfs_nr_ctxs] = NULL;
732 dbgfs_ctxs[dbgfs_nr_ctxs] = new_ctx;
733 dbgfs_fill_ctx_dir(dbgfs_dirs[dbgfs_nr_ctxs],
734 dbgfs_ctxs[dbgfs_nr_ctxs]);
740 static ssize_t dbgfs_mk_context_write(struct file *file,
741 const char __user *buf, size_t count, loff_t *ppos)
747 kbuf = user_input_str(buf, count, ppos);
749 return PTR_ERR(kbuf);
750 ctx_name = kmalloc(count + 1, GFP_KERNEL);
756 /* Trim white space */
757 if (sscanf(kbuf, "%s", ctx_name) != 1) {
762 mutex_lock(&damon_dbgfs_lock);
763 ret = dbgfs_mk_context(ctx_name);
766 mutex_unlock(&damon_dbgfs_lock);
775 * Remove a context of @name and its debugfs directory.
777 * This function should be called while holding damon_dbgfs_lock.
779 * Return 0 on success, negative error code otherwise.
781 static int dbgfs_rm_context(char *name)
783 struct dentry *root, *dir, **new_dirs;
784 struct damon_ctx **new_ctxs;
787 if (damon_nr_running_ctxs())
790 root = dbgfs_dirs[0];
794 dir = debugfs_lookup(name, root);
798 new_dirs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_dirs),
803 new_ctxs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_ctxs),
810 for (i = 0, j = 0; i < dbgfs_nr_ctxs; i++) {
811 if (dbgfs_dirs[i] == dir) {
812 debugfs_remove(dbgfs_dirs[i]);
813 dbgfs_destroy_ctx(dbgfs_ctxs[i]);
816 new_dirs[j] = dbgfs_dirs[i];
817 new_ctxs[j++] = dbgfs_ctxs[i];
823 dbgfs_dirs = new_dirs;
824 dbgfs_ctxs = new_ctxs;
830 static ssize_t dbgfs_rm_context_write(struct file *file,
831 const char __user *buf, size_t count, loff_t *ppos)
837 kbuf = user_input_str(buf, count, ppos);
839 return PTR_ERR(kbuf);
840 ctx_name = kmalloc(count + 1, GFP_KERNEL);
846 /* Trim white space */
847 if (sscanf(kbuf, "%s", ctx_name) != 1) {
852 mutex_lock(&damon_dbgfs_lock);
853 ret = dbgfs_rm_context(ctx_name);
856 mutex_unlock(&damon_dbgfs_lock);
864 static ssize_t dbgfs_monitor_on_read(struct file *file,
865 char __user *buf, size_t count, loff_t *ppos)
867 char monitor_on_buf[5];
868 bool monitor_on = damon_nr_running_ctxs() != 0;
871 len = scnprintf(monitor_on_buf, 5, monitor_on ? "on\n" : "off\n");
873 return simple_read_from_buffer(buf, count, ppos, monitor_on_buf, len);
876 static ssize_t dbgfs_monitor_on_write(struct file *file,
877 const char __user *buf, size_t count, loff_t *ppos)
882 kbuf = user_input_str(buf, count, ppos);
884 return PTR_ERR(kbuf);
886 /* Remove white space */
887 if (sscanf(kbuf, "%s", kbuf) != 1) {
892 mutex_lock(&damon_dbgfs_lock);
893 if (!strncmp(kbuf, "on", count)) {
896 for (i = 0; i < dbgfs_nr_ctxs; i++) {
897 if (damon_targets_empty(dbgfs_ctxs[i])) {
899 mutex_unlock(&damon_dbgfs_lock);
903 ret = damon_start(dbgfs_ctxs, dbgfs_nr_ctxs);
904 } else if (!strncmp(kbuf, "off", count)) {
905 ret = damon_stop(dbgfs_ctxs, dbgfs_nr_ctxs);
909 mutex_unlock(&damon_dbgfs_lock);
917 static const struct file_operations mk_contexts_fops = {
918 .write = dbgfs_mk_context_write,
921 static const struct file_operations rm_contexts_fops = {
922 .write = dbgfs_rm_context_write,
925 static const struct file_operations monitor_on_fops = {
926 .read = dbgfs_monitor_on_read,
927 .write = dbgfs_monitor_on_write,
930 static int __init __damon_dbgfs_init(void)
932 struct dentry *dbgfs_root;
933 const char * const file_names[] = {"mk_contexts", "rm_contexts",
935 const struct file_operations *fops[] = {&mk_contexts_fops,
936 &rm_contexts_fops, &monitor_on_fops};
939 dbgfs_root = debugfs_create_dir("damon", NULL);
941 for (i = 0; i < ARRAY_SIZE(file_names); i++)
942 debugfs_create_file(file_names[i], 0600, dbgfs_root, NULL,
944 dbgfs_fill_ctx_dir(dbgfs_root, dbgfs_ctxs[0]);
946 dbgfs_dirs = kmalloc_array(1, sizeof(dbgfs_root), GFP_KERNEL);
948 debugfs_remove(dbgfs_root);
951 dbgfs_dirs[0] = dbgfs_root;
957 * Functions for the initialization
960 static int __init damon_dbgfs_init(void)
964 mutex_lock(&damon_dbgfs_lock);
965 dbgfs_ctxs = kmalloc(sizeof(*dbgfs_ctxs), GFP_KERNEL);
968 dbgfs_ctxs[0] = dbgfs_new_ctx();
969 if (!dbgfs_ctxs[0]) {
975 rc = __damon_dbgfs_init();
977 kfree(dbgfs_ctxs[0]);
979 pr_err("%s: dbgfs init failed\n", __func__);
983 mutex_unlock(&damon_dbgfs_lock);
987 module_init(damon_dbgfs_init);
989 #include "dbgfs-test.h"