Received: by 2002:a25:e74b:0:0:0:0:0 with SMTP id e72csp814556ybh; Mon, 13 Jul 2020 01:46:45 -0700 (PDT) X-Google-Smtp-Source: ABdhPJyTRoatzyQ9yi3w5WVR+5BdxE53VXtzSUEjOCT2R++mcY5EK6IK19A1T7NHVP/aP8AiLoCE X-Received: by 2002:a17:906:364e:: with SMTP id r14mr60501009ejb.258.1594630005142; Mon, 13 Jul 2020 01:46:45 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1594630005; cv=none; d=google.com; s=arc-20160816; b=mTdoM0zqrCOjJJpMzRPAXJ1ev5U2SEZ1PYvyjjQ8IZIzp4qsM63iK+Q198587fawIa dO0T60ssrrZy8iXIblwB8ykZnr2yp9Z7SFzrIjw8ilX/lpVe75MnFWWfQtHsGe4KaLxo f4ELo3wh5OH4qhPLzieNsbOAGHvH8k8sj4rbNOEn8OsvYaNQgS92mhQBefn4+2/B6Ggr Esv2x94kE8n38vCkBr4WzmX7IWNmc3SIj04YU1OU/NltQv3Dxn/v1PmzzDQhtzfIvLfn l7rvuwe5cdkNt7wMGBMRq8USyFERxuGc0SG5oNr/kHJBYCfb/R3NIJjQB8qiapkDu8Kr bj+g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:ironport-sdr:dkim-signature; bh=9wWFctwv9PRi3nAfe8DKlLbThVB591xpO1WsSLFJMOk=; b=cT7xLW1bEupcGLsFrGMMiiGrtuYfx7HYcMqx2bGc+jjjpv3FJrNeaLmQbWFBtxIDc0 rM5eRfZsE534iAApdobQMCo8NCpdylCZk4CZFFIcrPs7D4G/geuuoV58AgEx0AdvK8NA Ht4rrObLaP5NxdsL+seDyptnM0BAfSSZPd0VvDC3ah0c+nj/yjWaXidkwuEHR3ZjJcqh JLOKrqOUfmqGoVKYriG/Ibv0+0miQp7I6BMCxEca/axWBSx9/Rpz5ilMcEa2ebhIpiUY VenZ2YfC8XExe9PM2KeacNq6M1YkOeG1ubzPxH3mQwIVi1/gLDzTiYr0ZYSyqfe30R6N 1Smw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@amazon.com header.s=amazon201209 header.b="QOlV0R5/"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=amazon.com Return-Path: Received: from vger.kernel.org (vger.kernel.org. [23.128.96.18]) by mx.google.com with ESMTP id bt23si8361235edb.545.2020.07.13.01.46.22; Mon, 13 Jul 2020 01:46:45 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@amazon.com header.s=amazon201209 header.b="QOlV0R5/"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=amazon.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729186AbgGMIpd (ORCPT + 99 others); Mon, 13 Jul 2020 04:45:33 -0400 Received: from smtp-fw-6001.amazon.com ([52.95.48.154]:22770 "EHLO smtp-fw-6001.amazon.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727834AbgGMIpc (ORCPT ); Mon, 13 Jul 2020 04:45:32 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amazon.com; i=@amazon.com; q=dns/txt; s=amazon201209; t=1594629928; x=1626165928; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version; bh=9wWFctwv9PRi3nAfe8DKlLbThVB591xpO1WsSLFJMOk=; b=QOlV0R5/8/A53ikJdHVmHnbUW/jigW9SnO24af3hzmL9tdXLA15RWkFf H0dxs/Ml1J8rCo2fvCTM0DBaNOQO30614qPqDx++g4I01v+bfd7PRBEK1 Nfc2zJ5kvUP+Zzabwy5e8Mw+jUK+UKbnMePQi7ckYAGN0wU9nbQbM2Jwh M=; IronPort-SDR: Y79Cqykdu3SjbFC4p3ui+uh9JxfDOLzFZJfRDcH6a0HVvZL7sDR8wM/It0X3Re1dedTRiMtzXI 5vwj2eTZVPYw== X-IronPort-AV: E=Sophos;i="5.75,346,1589241600"; d="scan'208";a="42915319" Received: from iad12-co-svc-p1-lb1-vlan3.amazon.com (HELO email-inbound-relay-2c-168cbb73.us-west-2.amazon.com) ([10.43.8.6]) by smtp-border-fw-out-6001.iad6.amazon.com with ESMTP; 13 Jul 2020 08:45:24 +0000 Received: from EX13MTAUEA002.ant.amazon.com (pdx4-ws-svc-p6-lb7-vlan2.pdx.amazon.com [10.170.41.162]) by email-inbound-relay-2c-168cbb73.us-west-2.amazon.com (Postfix) with ESMTPS id 499DEA1BDF; Mon, 13 Jul 2020 08:45:22 +0000 (UTC) Received: from EX13D31EUA004.ant.amazon.com (10.43.165.161) by EX13MTAUEA002.ant.amazon.com (10.43.61.77) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Mon, 13 Jul 2020 08:45:21 +0000 Received: from u886c93fd17d25d.ant.amazon.com (10.43.161.146) by EX13D31EUA004.ant.amazon.com (10.43.165.161) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Mon, 13 Jul 2020 08:45:05 +0000 From: SeongJae Park To: CC: SeongJae Park , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Subject: [PATCH v18 09/14] mm/damon: Implement a debugfs interface Date: Mon, 13 Jul 2020 10:41:39 +0200 Message-ID: <20200713084144.4430-10-sjpark@amazon.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20200713084144.4430-1-sjpark@amazon.com> References: <20200713084144.4430-1-sjpark@amazon.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [10.43.161.146] X-ClientProxiedBy: EX13P01UWA002.ant.amazon.com (10.43.160.46) To EX13D31EUA004.ant.amazon.com (10.43.165.161) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: SeongJae Park This commit implements a debugfs interface for DAMON. It works for the virtual address spaces monitoring. 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 start the monitoring. Record ------ DAMON supports 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 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 Reviewed-by: Leonard Foerster --- mm/damon.c | 381 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 380 insertions(+), 1 deletion(-) diff --git a/mm/damon.c b/mm/damon.c index 00df1a4c3d5c..df05bd821ff8 100644 --- a/mm/damon.c +++ b/mm/damon.c @@ -14,6 +14,7 @@ * - Functions for the access checking of the regions * - Functions for DAMON core logics and features * - Functions for the DAMON programming interface + * - Functions for the DAMON debugfs interface * - Functions for the module loading/unloading */ @@ -22,6 +23,7 @@ #define CREATE_TRACE_POINTS #include +#include #include #include #include @@ -68,6 +70,20 @@ /* Get a random number in [l, r) */ #define damon_rand(l, r) (l + prandom_u32() % (r - l)) +/* A monitoring context for debugfs interface users. */ +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, + + .init_target_regions = kdamond_init_vm_regions, + .update_target_regions = kdamond_update_vm_regions, + .prepare_access_checks = kdamond_prepare_vm_access_checks, + .check_accesses = kdamond_check_vm_accesses, +}; + /* * Construct a damon_region struct * @@ -1228,17 +1244,380 @@ int damon_set_attrs(struct damon_ctx *ctx, unsigned long sample_int, return 0; } +/* + * Functions for the DAMON debugfs interface + */ + +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; + int len; + + monitor_on = damon_kdamond_running(ctx); + len = snprintf(monitor_on_buf, 5, monitor_on ? "on\n" : "off\n"); + + return simple_read_from_buffer(buf, count, ppos, monitor_on_buf, len); +} + +/* + * Returns non-empty string on success, negarive error code otherwise. + */ +static char *user_input_str(const char __user *buf, size_t count, loff_t *ppos) +{ + char *kbuf; + ssize_t ret; + + /* We do not accept continuous write */ + if (*ppos) + return ERR_PTR(-EINVAL); + + kbuf = kmalloc(count + 1, GFP_KERNEL); + if (!kbuf) + return ERR_PTR(-ENOMEM); + + ret = simple_write_to_buffer(kbuf, count + 1, ppos, buf, count); + if (ret != count) { + kfree(kbuf); + return ERR_PTR(-EIO); + } + kbuf[ret] = '\0'; + + return kbuf; +} + +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 = count; + char *kbuf; + int err; + + kbuf = user_input_str(buf, count, ppos); + if (IS_ERR(kbuf)) + return PTR_ERR(kbuf); + + /* Remove white space */ + if (sscanf(kbuf, "%s", kbuf) != 1) + return -EINVAL; + if (!strncmp(kbuf, "on", count)) + err = damon_start(ctx); + else if (!strncmp(kbuf, "off", count)) + err = damon_stop(ctx); + else + return -EINVAL; + + if (err) + ret = err; + return ret; +} + +static ssize_t damon_sprint_pids(struct damon_ctx *ctx, char *buf, ssize_t len) +{ + struct damon_task *t; + int written = 0; + int rc; + + damon_for_each_task(t, ctx) { + rc = snprintf(&buf[written], len - written, "%d ", t->pid); + if (!rc) + return -ENOMEM; + written += rc; + } + if (written) + written -= 1; + written += snprintf(&buf[written], len - written, "\n"); + return written; +} + +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[320]; + + mutex_lock(&ctx->kdamond_lock); + len = damon_sprint_pids(ctx, pids_buf, 320); + mutex_unlock(&ctx->kdamond_lock); + if (len < 0) + return len; + + 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 if the conversion success, or + * NULL otherwise. + */ +static int *str_to_pids(const char *str, ssize_t len, ssize_t *nr_pids) +{ + int *pids; + const int max_nr_pids = 32; + int pid; + int pos = 0, parsed, ret; + + *nr_pids = 0; + pids = kmalloc_array(max_nr_pids, sizeof(pid), GFP_KERNEL); + if (!pids) + return NULL; + while (*nr_pids < max_nr_pids && pos < len) { + ret = sscanf(&str[pos], "%d%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; + char *kbuf; + int *targets; + ssize_t nr_targets; + ssize_t ret = count; + int err; + + kbuf = user_input_str(buf, count, ppos); + if (IS_ERR(kbuf)) + return PTR_ERR(kbuf); + + targets = str_to_pids(kbuf, ret, &nr_targets); + if (!targets) { + ret = -ENOMEM; + goto out; + } + + mutex_lock(&ctx->kdamond_lock); + if (ctx->kdamond) { + ret = -EINVAL; + goto unlock_out; + } + + err = damon_set_pids(ctx, targets, nr_targets); + if (err) + ret = err; +unlock_out: + mutex_unlock(&ctx->kdamond_lock); + kfree(targets); +out: + kfree(kbuf); + return ret; +} + +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[20 + MAX_RFILE_PATH_LEN]; + int ret; + + mutex_lock(&ctx->kdamond_lock); + ret = snprintf(record_buf, ARRAY_SIZE(record_buf), "%u %s\n", + ctx->rbuf_len, ctx->rfile_path); + mutex_unlock(&ctx->kdamond_lock); + return simple_read_from_buffer(buf, count, ppos, record_buf, ret); +} + +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 *kbuf; + unsigned int rbuf_len; + char rfile_path[MAX_RFILE_PATH_LEN]; + ssize_t ret = count; + int err; + + kbuf = user_input_str(buf, count, ppos); + if (IS_ERR(kbuf)) + return PTR_ERR(kbuf); + + if (sscanf(kbuf, "%u %s", + &rbuf_len, rfile_path) != 2) { + ret = -EINVAL; + goto out; + } + + mutex_lock(&ctx->kdamond_lock); + if (ctx->kdamond) { + ret = -EBUSY; + goto unlock_out; + } + + err = damon_set_recording(ctx, rbuf_len, rfile_path); + if (err) + ret = err; +unlock_out: + mutex_unlock(&ctx->kdamond_lock); +out: + kfree(kbuf); + return ret; +} + +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 kbuf[128]; + int ret; + + mutex_lock(&ctx->kdamond_lock); + ret = snprintf(kbuf, ARRAY_SIZE(kbuf), "%lu %lu %lu %lu %lu\n", + ctx->sample_interval, ctx->aggr_interval, + ctx->regions_update_interval, ctx->min_nr_regions, + ctx->max_nr_regions); + mutex_unlock(&ctx->kdamond_lock); + + return simple_read_from_buffer(buf, count, ppos, kbuf, ret); +} + +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 *kbuf; + ssize_t ret = count; + int err; + + kbuf = user_input_str(buf, count, ppos); + if (IS_ERR(kbuf)) + return PTR_ERR(kbuf); + + if (sscanf(kbuf, "%lu %lu %lu %lu %lu", + &s, &a, &r, &minr, &maxr) != 5) { + ret = -EINVAL; + goto out; + } + + mutex_lock(&ctx->kdamond_lock); + if (ctx->kdamond) { + ret = -EBUSY; + goto unlock_out; + } + + err = damon_set_attrs(ctx, s, a, r, minr, maxr); + if (err) + ret = err; +unlock_out: + mutex_unlock(&ctx->kdamond_lock); +out: + kfree(kbuf); + return ret; +} + +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 damon_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; + + rc = damon_set_recording(ctx, 1024 * 1024, "/damon.data"); + if (rc) + return rc; + + mutex_init(&ctx->kdamond_lock); + + INIT_LIST_HEAD(&ctx->tasks_list); + + return 0; +} + /* * Functions for the module loading/unloading */ static int __init damon_init(void) { - return 0; + int rc; + + rc = damon_init_user_ctx(); + if (rc) + return rc; + + rc = damon_debugfs_init(); + if (rc) + pr_err("%s: debugfs init failed\n", __func__); + + return rc; } static void __exit damon_exit(void) { + damon_stop(&damon_user_ctx); + debugfs_remove_recursive(debugfs_root); + + kfree(damon_user_ctx.rbuf); + kfree(damon_user_ctx.rfile_path); } module_init(damon_init); -- 2.17.1