From patchwork Tue Feb 4 06:23:07 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: SeongJae Park X-Patchwork-Id: 11364081 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id BDED914B4 for ; Tue, 4 Feb 2020 06:24:19 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 6FCB02086A for ; Tue, 4 Feb 2020 06:24:19 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Sh6Bs+7V" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6FCB02086A Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 948036B000C; Tue, 4 Feb 2020 01:24:18 -0500 (EST) Delivered-To: linux-mm-outgoing@kvack.org Received: by kanga.kvack.org (Postfix, from userid 40) id 8F8806B000D; Tue, 4 Feb 2020 01:24:18 -0500 (EST) X-Original-To: int-list-linux-mm@kvack.org X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 799426B000E; Tue, 4 Feb 2020 01:24:18 -0500 (EST) X-Original-To: linux-mm@kvack.org X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0218.hostedemail.com [216.40.44.218]) by kanga.kvack.org (Postfix) with ESMTP id 5D1726B000C for ; Tue, 4 Feb 2020 01:24:18 -0500 (EST) Received: from smtpin02.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay04.hostedemail.com (Postfix) with ESMTP id 16AC7249C for ; Tue, 4 Feb 2020 06:24:18 +0000 (UTC) X-FDA: 76451454996.02.move99_4285c4c547e3f X-Spam-Summary: 2,0,0,f99a409172977f5a,d41d8cd98f00b204,sj38.park@gmail.com,:akpm@linux-foundation.org:sjpark@amazon.de:acme@kernel.org:alexander.shishkin@linux.intel.com:amit@kernel.org:brendan.d.gregg@gmail.com:brendanhiggins@google.com:cai@lca.pw:colin.king@canonical.com:corbet@lwn.net:dwmw@amazon.com:jolsa@redhat.com:kirill@shutemov.name:mark.rutland@arm.com:mgorman@suse.de:minchan@kernel.org:mingo@redhat.com:namhyung@kernel.org:peterz@infradead.org:rdunlap@infradead.org:rostedt@goodmis.org:sj38.park@gmail.com:vdavydov.dev@gmail.com::linux-doc@vger.kernel.org:linux-kernel@vger.kernel.org,RULES_HIT:4:41:69:355:379:541:800:960:966:968:973:988:989:1260:1345:1359:1437:1605:1730:1747:1777:1792:2194:2196:2198:2199:2200:2201:2393:2559:2562:2638:2693:2892:2895:2901:2918:2924:2926:3138:3139:3140:3141:3142:3742:3865:3866:3867:3868:3870:3871:3872:3873:3874:4250:4321:4385:5007:6119:6261:6653:6742:6743:7576:7903:8603:8957:9010:9413:10004:11026:11473:11658:11914:12043:12291:12294:12295 :12296:1 X-HE-Tag: move99_4285c4c547e3f X-Filterd-Recvd-Size: 15398 Received: from mail-pl1-f193.google.com (mail-pl1-f193.google.com [209.85.214.193]) by imf42.hostedemail.com (Postfix) with ESMTP for ; Tue, 4 Feb 2020 06:24:17 +0000 (UTC) Received: by mail-pl1-f193.google.com with SMTP id t14so6834585plr.8 for ; Mon, 03 Feb 2020 22:24:16 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=MvKM1CZ6aMvLaWJ0D+59kHuYEYSh47NwjoPQm914yG8=; b=Sh6Bs+7V8Gla6ZXDutklqmYvd6pqY62tzdHZhIPwrMMnqi467xE8KVKz1/YGWdIH/W hbmaf9e8p0+yeQ8ia/uy+iqKtpapBba33G2RCwnuhH8Xf7pWmDcwl+pkY9E3s7sjJdx0 0G69il0TyaONPRQ9/n/ZEYagrW367xmY8DepYXdbZdOvrDI9CMmVNhkr6iJIOkGTAgSa Yd6cdg40jR617HO9uWYw05kya7xZ2i3b2DzYBeac2SKwRslABFVDS8vq+XnMvKcUCpSc FZ5IbyQd25efuQ7OI4tn3u9eOqcmgjyIhaT5ur5WdOf769gHXXeWpjpBVvMalDhKsu9t ktFg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=MvKM1CZ6aMvLaWJ0D+59kHuYEYSh47NwjoPQm914yG8=; b=RVPpUOnUYFFix5/CImz+Hbz3k5DnIf4zfVlMGzdcBkpzFue5S9uSwPEd4+v7IHBzNg WKyPbUu2n6M/TFm9STTKd+smNt5OHycRyKdDgHhH5x7rk5scLi1CUT2zVy4kXVR4wPcP 1Pr9M5gbz6X03HEluHl5zf4U2eOkAhwtljoEK+UM2eQy3ouEMQO0IcjPz1470E3yPwEG MHoxnDrBqyzTSO82rYQqCEUnnIDZImFyheiOTqW/rQ6Bsx0rTX5p7O893PBcKX3icw0I AfRt/zJVqDmjSIbz9LZm9YVC7R5638b6NbBlzE6iHjswhMkgTOrwAN7I9FbwIj6vtSfM 65ew== X-Gm-Message-State: APjAAAXVEnRG5NupU25Q8fX1QX4m3TjYS/PIWbINwaDxjOeAqylqeemW VYKmRAY8t1v2bhCQHJioxhs= X-Google-Smtp-Source: APXvYqzGFTa2GMOm2xxmiPXXuMlRkl5CZ6juXLNhL4q+PxETxC1ttR6BeOXXfO6aIVuohVWP8/UTsQ== X-Received: by 2002:a17:902:82c9:: with SMTP id u9mr27569172plz.264.1580797455989; Mon, 03 Feb 2020 22:24:15 -0800 (PST) Received: from localhost.localdomain ([106.254.212.20]) by smtp.gmail.com with ESMTPSA id u26sm21880240pfn.46.2020.02.03.22.24.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 03 Feb 2020 22:24:15 -0800 (PST) From: sj38.park@gmail.com To: akpm@linux-foundation.org Cc: SeongJae Park , acme@kernel.org, alexander.shishkin@linux.intel.com, amit@kernel.org, brendan.d.gregg@gmail.com, brendanhiggins@google.com, cai@lca.pw, colin.king@canonical.com, corbet@lwn.net, dwmw@amazon.com, jolsa@redhat.com, kirill@shutemov.name, mark.rutland@arm.com, mgorman@suse.de, minchan@kernel.org, mingo@redhat.com, namhyung@kernel.org, peterz@infradead.org, rdunlap@infradead.org, rostedt@goodmis.org, sj38.park@gmail.com, vdavydov.dev@gmail.com, linux-mm@kvack.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v3 06/11] mm/damon: Add debugfs interface Date: Tue, 4 Feb 2020 06:23:07 +0000 Message-Id: <20200204062312.19913-7-sj38.park@gmail.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200204062312.19913-1-sj38.park@gmail.com> References: <20200204062312.19913-1-sj38.park@gmail.com> X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: From: SeongJae Park This commit adds a debugfs interface for DAMON. DAMON exports four files, ``attrs``, ``pids``, ``record``, and ``monitor_on`` under its debugfs directory, ``/damon/``. Attributes ---------- Users can read and write the ``sampling interval``, ``aggregation interval``, ``regions update interval``, and min/max number of monitoring target regions by reading from and writing to the ``attrs`` file. For example, below commands set those values to 5 ms, 100 ms, 1,000 ms, 10, 1000 and check it again:: # cd /damon # echo 5000 100000 1000000 10 1000 > attrs # cat attrs 5000 100000 1000000 10 1000 Target PIDs ----------- Users can read and write the pids of current monitoring target processes by reading from and writing to the ``pids`` file. For example, below commands set processes having pids 42 and 4242 as the processes to be monitored and check it again:: # cd /damon # echo 42 4242 > pids # cat pids 42 4242 Note that setting the pids doesn't starts the monitoring. Record ------ DAMON support direct monitoring result record feature. The recorded results are first written to a buffer and flushed to a file in batch. Users can set the size of the buffer and the path to the result file by reading from and writing to the ``record`` file. For example, below commands set the buffer to be 4 KiB and the result to be saved in '/damon.data'. # cd /damon # echo 4096 /damon.data > pids # cat record 4096 /damon.data Turning On/Off -------------- You can check current status, start and stop the monitoring by reading from and writing to the ``monitor_on`` file. Writing ``on`` to the file starts DAMON to monitor the target processes with the attributes. Writing ``off`` to the file stops DAMON. DAMON also stops if every target processes is be terminated. Below example commands turn on, off, and check status of DAMON:: # cd /damon # echo on > monitor_on # echo off > monitor_on # cat monitor_on off Please note that you cannot write to the ``attrs`` and ``pids`` files while the monitoring is turned on. If you write to the files while DAMON is running, ``-EINVAL`` will be returned. Signed-off-by: SeongJae Park --- mm/damon.c | 348 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 347 insertions(+), 1 deletion(-) diff --git a/mm/damon.c b/mm/damon.c index 1c9299543678..f1d7200f3936 100644 --- a/mm/damon.c +++ b/mm/damon.c @@ -10,6 +10,7 @@ #define pr_fmt(fmt) "damon: " fmt #include +#include #include #include #include @@ -41,6 +42,24 @@ #define damon_for_each_task_safe(ctx, t, next) \ list_for_each_entry_safe(t, next, &(ctx)->tasks_list, list) +/* + * For each 'sample_interval', DAMON checks whether each region is accessed or + * not. It aggregates and keeps the access information (number of accesses to + * each region) for 'aggr_interval' and then flushes it to the result buffer if + * an 'aggr_interval' surpassed. And for each 'regions_update_interval', damon + * checks whether the memory mapping of the target tasks has changed (e.g., by + * mmap() calls from the applications) and applies the changes. + * + * All time intervals are in micro-seconds. + */ +static struct damon_ctx damon_user_ctx = { + .sample_interval = 5 * 1000, + .aggr_interval = 100 * 1000, + .regions_update_interval = 1000 * 1000, + .min_nr_regions = 10, + .max_nr_regions = 1000, +}; + #define LEN_RES_FILE_PATH 256 /* Get a random number in [l, r) */ @@ -1040,15 +1059,342 @@ int damon_set_attrs(struct damon_ctx *ctx, unsigned long sample_int, return 0; } +/* + * debugfs functions + */ + +static ssize_t debugfs_monitor_on_read(struct file *file, + char __user *buf, size_t count, loff_t *ppos) +{ + struct damon_ctx *ctx = &damon_user_ctx; + char monitor_on_buf[5]; + bool monitor_on; + + spin_lock(&ctx->kdamond_lock); + monitor_on = ctx->kdamond != NULL; + spin_unlock(&ctx->kdamond_lock); + + snprintf(monitor_on_buf, 5, monitor_on ? "on\n" : "off\n"); + + return simple_read_from_buffer(buf, count, ppos, monitor_on_buf, + monitor_on ? 3 : 4); +} + +static ssize_t debugfs_monitor_on_write(struct file *file, + const char __user *buf, size_t count, loff_t *ppos) +{ + struct damon_ctx *ctx = &damon_user_ctx; + ssize_t ret; + bool on = false; + char cmdbuf[5]; + + ret = simple_write_to_buffer(cmdbuf, 5, ppos, buf, count); + if (ret < 0) + return ret; + + if (sscanf(cmdbuf, "%s", cmdbuf) != 1) + return -EINVAL; + if (!strncmp(cmdbuf, "on", 5)) + on = true; + else if (!strncmp(cmdbuf, "off", 5)) + on = false; + else + return -EINVAL; + + if (damon_turn_kdamond(ctx, on)) + return -EINVAL; + + return ret; +} + +static ssize_t damon_sprint_pids(struct damon_ctx *ctx, char *buf, ssize_t len) +{ + char *cursor = buf; + struct damon_task *t; + + damon_for_each_task(ctx, t) { + snprintf(cursor, len, "%lu ", t->pid); + cursor += strnlen(cursor, len); + } + if (cursor != buf) + cursor--; + snprintf(cursor, len, "\n"); + return strnlen(buf, len); +} + +static ssize_t debugfs_pids_read(struct file *file, + char __user *buf, size_t count, loff_t *ppos) +{ + struct damon_ctx *ctx = &damon_user_ctx; + ssize_t len; + char pids_buf[512]; + + len = damon_sprint_pids(ctx, pids_buf, 512); + + return simple_read_from_buffer(buf, count, ppos, pids_buf, len); +} + +/* + * Converts a string into an array of unsigned long integers + * + * Returns an array of unsigned long integers that converted, or NULL if the + * input is wrong. + */ +static unsigned long *str_to_pids(const char *str, ssize_t len, + ssize_t *nr_pids) +{ + unsigned long *pids; + unsigned long pid; + int pos = 0, parsed, ret; + + *nr_pids = 0; + pids = kmalloc_array(256, sizeof(unsigned long), GFP_KERNEL); + while (*nr_pids < 256 && pos < len) { + ret = sscanf(&str[pos], "%lu%n", &pid, &parsed); + pos += parsed; + if (ret != 1) + break; + pids[*nr_pids] = pid; + *nr_pids += 1; + } + if (*nr_pids == 0) { + kfree(pids); + pids = NULL; + } + + return pids; +} + +static ssize_t debugfs_pids_write(struct file *file, + const char __user *buf, size_t count, loff_t *ppos) +{ + struct damon_ctx *ctx = &damon_user_ctx; + ssize_t ret; + unsigned long *targets; + ssize_t nr_targets; + char pids_buf[512]; + + ret = simple_write_to_buffer(pids_buf, 512, ppos, buf, count); + if (ret < 0) + return ret; + + targets = str_to_pids(pids_buf, ret, &nr_targets); + + spin_lock(&ctx->kdamond_lock); + if (ctx->kdamond) + goto monitor_running; + + damon_set_pids(ctx, targets, nr_targets); + spin_unlock(&ctx->kdamond_lock); + kfree(targets); + + return ret; + +monitor_running: + spin_unlock(&ctx->kdamond_lock); + pr_err("%s: kdamond is running. Turn it off first.\n", __func__); + return -EINVAL; +} + +static ssize_t debugfs_record_read(struct file *file, + char __user *buf, size_t count, loff_t *ppos) +{ + struct damon_ctx *ctx = &damon_user_ctx; + char record_buf[512]; + + snprintf(record_buf, 512, "%u %s\n", + ctx->rbuf_len, ctx->rfile_path); + return simple_read_from_buffer(buf, count, ppos, record_buf, + strnlen(record_buf, 512)); +} + +static ssize_t debugfs_record_write(struct file *file, + const char __user *buf, size_t count, loff_t *ppos) +{ + struct damon_ctx *ctx = &damon_user_ctx; + char record_buf[512]; + unsigned int rbuf_len; + char res_file_path[LEN_RES_FILE_PATH]; + ssize_t ret; + + if (count > 512) { + pr_err("record debugfs input is too large: %s\n", buf); + return -ENOMEM; + } + + ret = simple_write_to_buffer(record_buf, 512, ppos, buf, count); + if (ret < 0) + return ret; + if (sscanf(record_buf, "%u %s", + &rbuf_len, res_file_path) != 2) + return -EINVAL; + + spin_lock(&ctx->kdamond_lock); + if (ctx->kdamond) + goto monitor_running; + + damon_set_recording(ctx, rbuf_len, res_file_path); + spin_unlock(&ctx->kdamond_lock); + + return ret; + +monitor_running: + spin_unlock(&ctx->kdamond_lock); + pr_err("%s: kdamond is running. Turn it off first.\n", __func__); + return -EINVAL; +} + + +static ssize_t debugfs_attrs_read(struct file *file, + char __user *buf, size_t count, loff_t *ppos) +{ + struct damon_ctx *ctx = &damon_user_ctx; + char attrs_buf[256]; + + snprintf(attrs_buf, 256, "%lu %lu %lu %lu %lu\n", + ctx->sample_interval, ctx->aggr_interval, + ctx->regions_update_interval, ctx->min_nr_regions, + ctx->max_nr_regions); + + return simple_read_from_buffer(buf, count, ppos, attrs_buf, + strnlen(attrs_buf, 256)); +} + +static ssize_t debugfs_attrs_write(struct file *file, + const char __user *buf, size_t count, loff_t *ppos) +{ + struct damon_ctx *ctx = &damon_user_ctx; + unsigned long s, a, r, minr, maxr; + char attrs_buf[256]; + ssize_t ret; + + if (count > 256) { + pr_err("attributes stream is too large: %s\n", buf); + return -ENOMEM; + } + + ret = simple_write_to_buffer(attrs_buf, 256, ppos, buf, count); + if (ret < 0) + return ret; + + if (sscanf(attrs_buf, "%lu %lu %lu %lu %lu", + &s, &a, &r, &minr, &maxr) != 5) + return -EINVAL; + + spin_lock(&ctx->kdamond_lock); + if (ctx->kdamond) + goto monitor_running; + + damon_set_attrs(ctx, s, a, r, minr, maxr); + spin_unlock(&ctx->kdamond_lock); + + return ret; + +monitor_running: + spin_unlock(&ctx->kdamond_lock); + pr_err("%s: kdamond is running. Turn it off first.\n", __func__); + return -EINVAL; +} + +static const struct file_operations monitor_on_fops = { + .owner = THIS_MODULE, + .read = debugfs_monitor_on_read, + .write = debugfs_monitor_on_write, +}; + +static const struct file_operations pids_fops = { + .owner = THIS_MODULE, + .read = debugfs_pids_read, + .write = debugfs_pids_write, +}; + +static const struct file_operations record_fops = { + .owner = THIS_MODULE, + .read = debugfs_record_read, + .write = debugfs_record_write, +}; + +static const struct file_operations attrs_fops = { + .owner = THIS_MODULE, + .read = debugfs_attrs_read, + .write = debugfs_attrs_write, +}; + +static struct dentry *debugfs_root; + +static int __init debugfs_init(void) +{ + const char * const file_names[] = {"attrs", "record", + "pids", "monitor_on"}; + const struct file_operations *fops[] = {&attrs_fops, &record_fops, + &pids_fops, &monitor_on_fops}; + int i; + + debugfs_root = debugfs_create_dir("damon", NULL); + if (!debugfs_root) { + pr_err("failed to create the debugfs dir\n"); + return -ENOMEM; + } + + for (i = 0; i < ARRAY_SIZE(file_names); i++) { + if (!debugfs_create_file(file_names[i], 0600, debugfs_root, + NULL, fops[i])) { + pr_err("failed to create %s file\n", file_names[i]); + return -ENOMEM; + } + } + + return 0; +} + +static int __init damon_init_user_ctx(void) +{ + int rc; + + struct damon_ctx *ctx = &damon_user_ctx; + + ktime_get_coarse_ts64(&ctx->last_aggregation); + ctx->last_regions_update = ctx->last_aggregation; + + ctx->rbuf_offset = 0; + rc = damon_set_recording(ctx, 4096, "/damon.data"); + if (rc) + return rc; + + ctx->kdamond = NULL; + ctx->kdamond_stop = false; + spin_lock_init(&ctx->kdamond_lock); + + prandom_seed_state(&ctx->rndseed, 42); + INIT_LIST_HEAD(&ctx->tasks_list); + + ctx->sample_cb = NULL; + ctx->aggregate_cb = NULL; + + return 0; +} + static int __init damon_init(void) { + int rc; + pr_info("init\n"); - return 0; + rc = damon_init_user_ctx(); + if (rc) + return rc; + + return debugfs_init(); } static void __exit damon_exit(void) { + damon_turn_kdamond(&damon_user_ctx, false); + debugfs_remove_recursive(debugfs_root); + + kfree(damon_user_ctx.rbuf); + kfree(damon_user_ctx.rfile_path); + pr_info("exit\n"); }