14bc05954SSeongJae Park // SPDX-License-Identifier: GPL-2.0
24bc05954SSeongJae Park /*
34bc05954SSeongJae Park * DAMON Debugfs Interface
44bc05954SSeongJae Park *
54bc05954SSeongJae Park * Author: SeongJae Park <sjpark@amazon.de>
64bc05954SSeongJae Park */
74bc05954SSeongJae Park
84bc05954SSeongJae Park #define pr_fmt(fmt) "damon-dbgfs: " fmt
94bc05954SSeongJae Park
104bc05954SSeongJae Park #include <linux/damon.h>
114bc05954SSeongJae Park #include <linux/debugfs.h>
124bc05954SSeongJae Park #include <linux/file.h>
134bc05954SSeongJae Park #include <linux/mm.h>
144bc05954SSeongJae Park #include <linux/module.h>
154bc05954SSeongJae Park #include <linux/page_idle.h>
164bc05954SSeongJae Park #include <linux/slab.h>
174bc05954SSeongJae Park
184bc05954SSeongJae Park static struct damon_ctx **dbgfs_ctxs;
194bc05954SSeongJae Park static int dbgfs_nr_ctxs;
204bc05954SSeongJae Park static struct dentry **dbgfs_dirs;
2175c1c2b5SSeongJae Park static DEFINE_MUTEX(damon_dbgfs_lock);
224bc05954SSeongJae Park
damon_dbgfs_warn_deprecation(void)23*620932cdSSeongJae Park static void damon_dbgfs_warn_deprecation(void)
24*620932cdSSeongJae Park {
25*620932cdSSeongJae Park pr_warn_once("DAMON debugfs interface is deprecated, "
26*620932cdSSeongJae Park "so users should move to DAMON_SYSFS. If you cannot, "
27*620932cdSSeongJae Park "please report your usecase to damon@lists.linux.dev and "
28*620932cdSSeongJae Park "linux-mm@kvack.org.\n");
29*620932cdSSeongJae Park }
30*620932cdSSeongJae Park
314bc05954SSeongJae Park /*
324bc05954SSeongJae Park * Returns non-empty string on success, negative error code otherwise.
334bc05954SSeongJae Park */
user_input_str(const char __user * buf,size_t count,loff_t * ppos)344bc05954SSeongJae Park static char *user_input_str(const char __user *buf, size_t count, loff_t *ppos)
354bc05954SSeongJae Park {
364bc05954SSeongJae Park char *kbuf;
374bc05954SSeongJae Park ssize_t ret;
384bc05954SSeongJae Park
394bc05954SSeongJae Park /* We do not accept continuous write */
404bc05954SSeongJae Park if (*ppos)
414bc05954SSeongJae Park return ERR_PTR(-EINVAL);
424bc05954SSeongJae Park
43db7a347bSSeongJae Park kbuf = kmalloc(count + 1, GFP_KERNEL | __GFP_NOWARN);
444bc05954SSeongJae Park if (!kbuf)
454bc05954SSeongJae Park return ERR_PTR(-ENOMEM);
464bc05954SSeongJae Park
474bc05954SSeongJae Park ret = simple_write_to_buffer(kbuf, count + 1, ppos, buf, count);
484bc05954SSeongJae Park if (ret != count) {
494bc05954SSeongJae Park kfree(kbuf);
504bc05954SSeongJae Park return ERR_PTR(-EIO);
514bc05954SSeongJae Park }
524bc05954SSeongJae Park kbuf[ret] = '\0';
534bc05954SSeongJae Park
544bc05954SSeongJae Park return kbuf;
554bc05954SSeongJae Park }
564bc05954SSeongJae Park
dbgfs_attrs_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)574bc05954SSeongJae Park static ssize_t dbgfs_attrs_read(struct file *file,
584bc05954SSeongJae Park char __user *buf, size_t count, loff_t *ppos)
594bc05954SSeongJae Park {
604bc05954SSeongJae Park struct damon_ctx *ctx = file->private_data;
614bc05954SSeongJae Park char kbuf[128];
624bc05954SSeongJae Park int ret;
634bc05954SSeongJae Park
644bc05954SSeongJae Park mutex_lock(&ctx->kdamond_lock);
654bc05954SSeongJae Park ret = scnprintf(kbuf, ARRAY_SIZE(kbuf), "%lu %lu %lu %lu %lu\n",
66cbeaa77bSSeongJae Park ctx->attrs.sample_interval, ctx->attrs.aggr_interval,
67cbeaa77bSSeongJae Park ctx->attrs.ops_update_interval,
68cbeaa77bSSeongJae Park ctx->attrs.min_nr_regions, ctx->attrs.max_nr_regions);
694bc05954SSeongJae Park mutex_unlock(&ctx->kdamond_lock);
704bc05954SSeongJae Park
714bc05954SSeongJae Park return simple_read_from_buffer(buf, count, ppos, kbuf, ret);
724bc05954SSeongJae Park }
734bc05954SSeongJae Park
dbgfs_attrs_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)744bc05954SSeongJae Park static ssize_t dbgfs_attrs_write(struct file *file,
754bc05954SSeongJae Park const char __user *buf, size_t count, loff_t *ppos)
764bc05954SSeongJae Park {
774bc05954SSeongJae Park struct damon_ctx *ctx = file->private_data;
78bead3b00SSeongJae Park struct damon_attrs attrs;
794bc05954SSeongJae Park char *kbuf;
809210622aSRongwei Wang ssize_t ret;
814bc05954SSeongJae Park
824bc05954SSeongJae Park kbuf = user_input_str(buf, count, ppos);
834bc05954SSeongJae Park if (IS_ERR(kbuf))
844bc05954SSeongJae Park return PTR_ERR(kbuf);
854bc05954SSeongJae Park
864bc05954SSeongJae Park if (sscanf(kbuf, "%lu %lu %lu %lu %lu",
87bead3b00SSeongJae Park &attrs.sample_interval, &attrs.aggr_interval,
88bead3b00SSeongJae Park &attrs.ops_update_interval,
89bead3b00SSeongJae Park &attrs.min_nr_regions,
90bead3b00SSeongJae Park &attrs.max_nr_regions) != 5) {
914bc05954SSeongJae Park ret = -EINVAL;
924bc05954SSeongJae Park goto out;
934bc05954SSeongJae Park }
944bc05954SSeongJae Park
954bc05954SSeongJae Park mutex_lock(&ctx->kdamond_lock);
964bc05954SSeongJae Park if (ctx->kdamond) {
974bc05954SSeongJae Park ret = -EBUSY;
984bc05954SSeongJae Park goto unlock_out;
994bc05954SSeongJae Park }
1004bc05954SSeongJae Park
101bead3b00SSeongJae Park ret = damon_set_attrs(ctx, &attrs);
1029210622aSRongwei Wang if (!ret)
1039210622aSRongwei Wang ret = count;
1044bc05954SSeongJae Park unlock_out:
1054bc05954SSeongJae Park mutex_unlock(&ctx->kdamond_lock);
1064bc05954SSeongJae Park out:
1074bc05954SSeongJae Park kfree(kbuf);
1084bc05954SSeongJae Park return ret;
1094bc05954SSeongJae Park }
1104bc05954SSeongJae Park
111c364f9afSSeongJae Park /*
112c364f9afSSeongJae Park * Return corresponding dbgfs' scheme action value (int) for the given
113c364f9afSSeongJae Park * damos_action if the given damos_action value is valid and supported by
114c364f9afSSeongJae Park * dbgfs, negative error code otherwise.
115c364f9afSSeongJae Park */
damos_action_to_dbgfs_scheme_action(enum damos_action action)116c364f9afSSeongJae Park static int damos_action_to_dbgfs_scheme_action(enum damos_action action)
117c364f9afSSeongJae Park {
118c364f9afSSeongJae Park switch (action) {
119c364f9afSSeongJae Park case DAMOS_WILLNEED:
120c364f9afSSeongJae Park return 0;
121c364f9afSSeongJae Park case DAMOS_COLD:
122c364f9afSSeongJae Park return 1;
123c364f9afSSeongJae Park case DAMOS_PAGEOUT:
124c364f9afSSeongJae Park return 2;
125c364f9afSSeongJae Park case DAMOS_HUGEPAGE:
126c364f9afSSeongJae Park return 3;
127c364f9afSSeongJae Park case DAMOS_NOHUGEPAGE:
128c364f9afSSeongJae Park return 4;
129c364f9afSSeongJae Park case DAMOS_STAT:
130c364f9afSSeongJae Park return 5;
131c364f9afSSeongJae Park default:
132c364f9afSSeongJae Park return -EINVAL;
133c364f9afSSeongJae Park }
134c364f9afSSeongJae Park }
135c364f9afSSeongJae Park
sprint_schemes(struct damon_ctx * c,char * buf,ssize_t len)136af122dd8SSeongJae Park static ssize_t sprint_schemes(struct damon_ctx *c, char *buf, ssize_t len)
137af122dd8SSeongJae Park {
138af122dd8SSeongJae Park struct damos *s;
139af122dd8SSeongJae Park int written = 0;
140af122dd8SSeongJae Park int rc;
141af122dd8SSeongJae Park
142af122dd8SSeongJae Park damon_for_each_scheme(s, c) {
143af122dd8SSeongJae Park rc = scnprintf(&buf[written], len - written,
1443a619fdbSSeongJae Park "%lu %lu %u %u %u %u %d %lu %lu %lu %u %u %u %d %lu %lu %lu %lu %lu %lu %lu %lu %lu\n",
145f5a79d7cSYajun Deng s->pattern.min_sz_region,
146f5a79d7cSYajun Deng s->pattern.max_sz_region,
147f5a79d7cSYajun Deng s->pattern.min_nr_accesses,
148f5a79d7cSYajun Deng s->pattern.max_nr_accesses,
149f5a79d7cSYajun Deng s->pattern.min_age_region,
150f5a79d7cSYajun Deng s->pattern.max_age_region,
151c364f9afSSeongJae Park damos_action_to_dbgfs_scheme_action(s->action),
152d7d0ec85SSeongJae Park s->quota.ms, s->quota.sz,
153d7d0ec85SSeongJae Park s->quota.reset_interval,
154f4a68b4aSSeongJae Park s->quota.weight_sz,
155f4a68b4aSSeongJae Park s->quota.weight_nr_accesses,
156f4a68b4aSSeongJae Park s->quota.weight_age,
157ae666a6dSSeongJae Park s->wmarks.metric, s->wmarks.interval,
158ae666a6dSSeongJae Park s->wmarks.high, s->wmarks.mid, s->wmarks.low,
1593a619fdbSSeongJae Park s->stat.nr_tried, s->stat.sz_tried,
1603a619fdbSSeongJae Park s->stat.nr_applied, s->stat.sz_applied,
1613a619fdbSSeongJae Park s->stat.qt_exceeds);
162af122dd8SSeongJae Park if (!rc)
163af122dd8SSeongJae Park return -ENOMEM;
164af122dd8SSeongJae Park
165af122dd8SSeongJae Park written += rc;
166af122dd8SSeongJae Park }
167af122dd8SSeongJae Park return written;
168af122dd8SSeongJae Park }
169af122dd8SSeongJae Park
dbgfs_schemes_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)170af122dd8SSeongJae Park static ssize_t dbgfs_schemes_read(struct file *file, char __user *buf,
171af122dd8SSeongJae Park size_t count, loff_t *ppos)
172af122dd8SSeongJae Park {
173af122dd8SSeongJae Park struct damon_ctx *ctx = file->private_data;
174af122dd8SSeongJae Park char *kbuf;
175af122dd8SSeongJae Park ssize_t len;
176af122dd8SSeongJae Park
177db7a347bSSeongJae Park kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN);
178af122dd8SSeongJae Park if (!kbuf)
179af122dd8SSeongJae Park return -ENOMEM;
180af122dd8SSeongJae Park
181af122dd8SSeongJae Park mutex_lock(&ctx->kdamond_lock);
182af122dd8SSeongJae Park len = sprint_schemes(ctx, kbuf, count);
183af122dd8SSeongJae Park mutex_unlock(&ctx->kdamond_lock);
184af122dd8SSeongJae Park if (len < 0)
185af122dd8SSeongJae Park goto out;
186af122dd8SSeongJae Park len = simple_read_from_buffer(buf, count, ppos, kbuf, len);
187af122dd8SSeongJae Park
188af122dd8SSeongJae Park out:
189af122dd8SSeongJae Park kfree(kbuf);
190af122dd8SSeongJae Park return len;
191af122dd8SSeongJae Park }
192af122dd8SSeongJae Park
free_schemes_arr(struct damos ** schemes,ssize_t nr_schemes)193af122dd8SSeongJae Park static void free_schemes_arr(struct damos **schemes, ssize_t nr_schemes)
194af122dd8SSeongJae Park {
195af122dd8SSeongJae Park ssize_t i;
196af122dd8SSeongJae Park
197af122dd8SSeongJae Park for (i = 0; i < nr_schemes; i++)
198af122dd8SSeongJae Park kfree(schemes[i]);
199af122dd8SSeongJae Park kfree(schemes);
200af122dd8SSeongJae Park }
201af122dd8SSeongJae Park
202c364f9afSSeongJae Park /*
203c364f9afSSeongJae Park * Return corresponding damos_action for the given dbgfs input for a scheme
204c364f9afSSeongJae Park * action if the input is valid, negative error code otherwise.
205c364f9afSSeongJae Park */
dbgfs_scheme_action_to_damos_action(int dbgfs_action)206c364f9afSSeongJae Park static enum damos_action dbgfs_scheme_action_to_damos_action(int dbgfs_action)
207af122dd8SSeongJae Park {
208c364f9afSSeongJae Park switch (dbgfs_action) {
209c364f9afSSeongJae Park case 0:
210c364f9afSSeongJae Park return DAMOS_WILLNEED;
211c364f9afSSeongJae Park case 1:
212c364f9afSSeongJae Park return DAMOS_COLD;
213c364f9afSSeongJae Park case 2:
214c364f9afSSeongJae Park return DAMOS_PAGEOUT;
215c364f9afSSeongJae Park case 3:
216c364f9afSSeongJae Park return DAMOS_HUGEPAGE;
217c364f9afSSeongJae Park case 4:
218c364f9afSSeongJae Park return DAMOS_NOHUGEPAGE;
219c364f9afSSeongJae Park case 5:
220c364f9afSSeongJae Park return DAMOS_STAT;
221af122dd8SSeongJae Park default:
222c364f9afSSeongJae Park return -EINVAL;
223af122dd8SSeongJae Park }
224af122dd8SSeongJae Park }
225af122dd8SSeongJae Park
226af122dd8SSeongJae Park /*
227af122dd8SSeongJae Park * Converts a string into an array of struct damos pointers
228af122dd8SSeongJae Park *
229af122dd8SSeongJae Park * Returns an array of struct damos pointers that converted if the conversion
230af122dd8SSeongJae Park * success, or NULL otherwise.
231af122dd8SSeongJae Park */
str_to_schemes(const char * str,ssize_t len,ssize_t * nr_schemes)232af122dd8SSeongJae Park static struct damos **str_to_schemes(const char *str, ssize_t len,
233af122dd8SSeongJae Park ssize_t *nr_schemes)
234af122dd8SSeongJae Park {
235af122dd8SSeongJae Park struct damos *scheme, **schemes;
236af122dd8SSeongJae Park const int max_nr_schemes = 256;
237af122dd8SSeongJae Park int pos = 0, parsed, ret;
238c364f9afSSeongJae Park unsigned int action_input;
239c364f9afSSeongJae Park enum damos_action action;
240af122dd8SSeongJae Park
241af122dd8SSeongJae Park schemes = kmalloc_array(max_nr_schemes, sizeof(scheme),
242af122dd8SSeongJae Park GFP_KERNEL);
243af122dd8SSeongJae Park if (!schemes)
244af122dd8SSeongJae Park return NULL;
245af122dd8SSeongJae Park
246af122dd8SSeongJae Park *nr_schemes = 0;
247af122dd8SSeongJae Park while (pos < len && *nr_schemes < max_nr_schemes) {
248f5a79d7cSYajun Deng struct damos_access_pattern pattern = {};
2492b8a248dSSeongJae Park struct damos_quota quota = {};
250ae666a6dSSeongJae Park struct damos_watermarks wmarks;
2512b8a248dSSeongJae Park
252f4a68b4aSSeongJae Park ret = sscanf(&str[pos],
253ae666a6dSSeongJae Park "%lu %lu %u %u %u %u %u %lu %lu %lu %u %u %u %u %lu %lu %lu %lu%n",
254f5a79d7cSYajun Deng &pattern.min_sz_region, &pattern.max_sz_region,
255f5a79d7cSYajun Deng &pattern.min_nr_accesses,
256f5a79d7cSYajun Deng &pattern.max_nr_accesses,
257f5a79d7cSYajun Deng &pattern.min_age_region,
258f5a79d7cSYajun Deng &pattern.max_age_region,
259f5a79d7cSYajun Deng &action_input, "a.ms,
260f4a68b4aSSeongJae Park "a.sz, "a.reset_interval,
261f4a68b4aSSeongJae Park "a.weight_sz, "a.weight_nr_accesses,
262ae666a6dSSeongJae Park "a.weight_age, &wmarks.metric,
263ae666a6dSSeongJae Park &wmarks.interval, &wmarks.high, &wmarks.mid,
264ae666a6dSSeongJae Park &wmarks.low, &parsed);
265ae666a6dSSeongJae Park if (ret != 18)
266af122dd8SSeongJae Park break;
267c364f9afSSeongJae Park action = dbgfs_scheme_action_to_damos_action(action_input);
268c364f9afSSeongJae Park if ((int)action < 0)
269af122dd8SSeongJae Park goto fail;
270af122dd8SSeongJae Park
271f5a79d7cSYajun Deng if (pattern.min_sz_region > pattern.max_sz_region ||
272f5a79d7cSYajun Deng pattern.min_nr_accesses > pattern.max_nr_accesses ||
273f5a79d7cSYajun Deng pattern.min_age_region > pattern.max_age_region)
274c89ae63eSXin Hao goto fail;
275c89ae63eSXin Hao
276c89ae63eSXin Hao if (wmarks.high < wmarks.mid || wmarks.high < wmarks.low ||
277c89ae63eSXin Hao wmarks.mid < wmarks.low)
278c89ae63eSXin Hao goto fail;
279c89ae63eSXin Hao
280af122dd8SSeongJae Park pos += parsed;
281f5a79d7cSYajun Deng scheme = damon_new_scheme(&pattern, action, "a, &wmarks);
282af122dd8SSeongJae Park if (!scheme)
283af122dd8SSeongJae Park goto fail;
284af122dd8SSeongJae Park
285af122dd8SSeongJae Park schemes[*nr_schemes] = scheme;
286af122dd8SSeongJae Park *nr_schemes += 1;
287af122dd8SSeongJae Park }
288af122dd8SSeongJae Park return schemes;
289af122dd8SSeongJae Park fail:
290af122dd8SSeongJae Park free_schemes_arr(schemes, *nr_schemes);
291af122dd8SSeongJae Park return NULL;
292af122dd8SSeongJae Park }
293af122dd8SSeongJae Park
dbgfs_schemes_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)294af122dd8SSeongJae Park static ssize_t dbgfs_schemes_write(struct file *file, const char __user *buf,
295af122dd8SSeongJae Park size_t count, loff_t *ppos)
296af122dd8SSeongJae Park {
297af122dd8SSeongJae Park struct damon_ctx *ctx = file->private_data;
298af122dd8SSeongJae Park char *kbuf;
299af122dd8SSeongJae Park struct damos **schemes;
3009210622aSRongwei Wang ssize_t nr_schemes = 0, ret;
301af122dd8SSeongJae Park
302af122dd8SSeongJae Park kbuf = user_input_str(buf, count, ppos);
303af122dd8SSeongJae Park if (IS_ERR(kbuf))
304af122dd8SSeongJae Park return PTR_ERR(kbuf);
305af122dd8SSeongJae Park
3069210622aSRongwei Wang schemes = str_to_schemes(kbuf, count, &nr_schemes);
307af122dd8SSeongJae Park if (!schemes) {
308af122dd8SSeongJae Park ret = -EINVAL;
309af122dd8SSeongJae Park goto out;
310af122dd8SSeongJae Park }
311af122dd8SSeongJae Park
312af122dd8SSeongJae Park mutex_lock(&ctx->kdamond_lock);
313af122dd8SSeongJae Park if (ctx->kdamond) {
314af122dd8SSeongJae Park ret = -EBUSY;
315af122dd8SSeongJae Park goto unlock_out;
316af122dd8SSeongJae Park }
317af122dd8SSeongJae Park
318cc713520SKaixu Xia damon_set_schemes(ctx, schemes, nr_schemes);
3199210622aSRongwei Wang ret = count;
320af122dd8SSeongJae Park nr_schemes = 0;
3219210622aSRongwei Wang
322af122dd8SSeongJae Park unlock_out:
323af122dd8SSeongJae Park mutex_unlock(&ctx->kdamond_lock);
324af122dd8SSeongJae Park free_schemes_arr(schemes, nr_schemes);
325af122dd8SSeongJae Park out:
326af122dd8SSeongJae Park kfree(kbuf);
327af122dd8SSeongJae Park return ret;
328af122dd8SSeongJae Park }
329af122dd8SSeongJae Park
sprint_target_ids(struct damon_ctx * ctx,char * buf,ssize_t len)3304bc05954SSeongJae Park static ssize_t sprint_target_ids(struct damon_ctx *ctx, char *buf, ssize_t len)
3314bc05954SSeongJae Park {
3324bc05954SSeongJae Park struct damon_target *t;
3331971bd63SSeongJae Park int id;
3344bc05954SSeongJae Park int written = 0;
3354bc05954SSeongJae Park int rc;
3364bc05954SSeongJae Park
3374bc05954SSeongJae Park damon_for_each_target(t, ctx) {
338c9e124e0SSeongJae Park if (damon_target_has_pid(ctx))
3394bc05954SSeongJae Park /* Show pid numbers to debugfs users */
3401971bd63SSeongJae Park id = pid_vnr(t->pid);
3411971bd63SSeongJae Park else
3421971bd63SSeongJae Park /* Show 42 for physical address space, just for fun */
3431971bd63SSeongJae Park id = 42;
3444bc05954SSeongJae Park
3451971bd63SSeongJae Park rc = scnprintf(&buf[written], len - written, "%d ", id);
3464bc05954SSeongJae Park if (!rc)
3474bc05954SSeongJae Park return -ENOMEM;
3484bc05954SSeongJae Park written += rc;
3494bc05954SSeongJae Park }
3504bc05954SSeongJae Park if (written)
3514bc05954SSeongJae Park written -= 1;
3524bc05954SSeongJae Park written += scnprintf(&buf[written], len - written, "\n");
3534bc05954SSeongJae Park return written;
3544bc05954SSeongJae Park }
3554bc05954SSeongJae Park
dbgfs_target_ids_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)3564bc05954SSeongJae Park static ssize_t dbgfs_target_ids_read(struct file *file,
3574bc05954SSeongJae Park char __user *buf, size_t count, loff_t *ppos)
3584bc05954SSeongJae Park {
3594bc05954SSeongJae Park struct damon_ctx *ctx = file->private_data;
3604bc05954SSeongJae Park ssize_t len;
3614bc05954SSeongJae Park char ids_buf[320];
3624bc05954SSeongJae Park
3634bc05954SSeongJae Park mutex_lock(&ctx->kdamond_lock);
3644bc05954SSeongJae Park len = sprint_target_ids(ctx, ids_buf, 320);
3654bc05954SSeongJae Park mutex_unlock(&ctx->kdamond_lock);
3664bc05954SSeongJae Park if (len < 0)
3674bc05954SSeongJae Park return len;
3684bc05954SSeongJae Park
3694bc05954SSeongJae Park return simple_read_from_buffer(buf, count, ppos, ids_buf, len);
3704bc05954SSeongJae Park }
3714bc05954SSeongJae Park
3724bc05954SSeongJae Park /*
3731971bd63SSeongJae Park * Converts a string into an integers array
3744bc05954SSeongJae Park *
3751971bd63SSeongJae Park * Returns an array of integers array if the conversion success, or NULL
3761971bd63SSeongJae Park * otherwise.
3774bc05954SSeongJae Park */
str_to_ints(const char * str,ssize_t len,ssize_t * nr_ints)3781971bd63SSeongJae Park static int *str_to_ints(const char *str, ssize_t len, ssize_t *nr_ints)
3794bc05954SSeongJae Park {
3801971bd63SSeongJae Park int *array;
3811971bd63SSeongJae Park const int max_nr_ints = 32;
3821971bd63SSeongJae Park int nr;
3834bc05954SSeongJae Park int pos = 0, parsed, ret;
3844bc05954SSeongJae Park
3851971bd63SSeongJae Park *nr_ints = 0;
3861971bd63SSeongJae Park array = kmalloc_array(max_nr_ints, sizeof(*array), GFP_KERNEL);
3871971bd63SSeongJae Park if (!array)
3884bc05954SSeongJae Park return NULL;
3891971bd63SSeongJae Park while (*nr_ints < max_nr_ints && pos < len) {
3901971bd63SSeongJae Park ret = sscanf(&str[pos], "%d%n", &nr, &parsed);
3914bc05954SSeongJae Park pos += parsed;
3924bc05954SSeongJae Park if (ret != 1)
3934bc05954SSeongJae Park break;
3941971bd63SSeongJae Park array[*nr_ints] = nr;
3951971bd63SSeongJae Park *nr_ints += 1;
3964bc05954SSeongJae Park }
3974bc05954SSeongJae Park
3981971bd63SSeongJae Park return array;
3994bc05954SSeongJae Park }
4004bc05954SSeongJae Park
dbgfs_put_pids(struct pid ** pids,int nr_pids)4011971bd63SSeongJae Park static void dbgfs_put_pids(struct pid **pids, int nr_pids)
4024bc05954SSeongJae Park {
4034bc05954SSeongJae Park int i;
4044bc05954SSeongJae Park
4051971bd63SSeongJae Park for (i = 0; i < nr_pids; i++)
4061971bd63SSeongJae Park put_pid(pids[i]);
4071971bd63SSeongJae Park }
4081971bd63SSeongJae Park
4091971bd63SSeongJae Park /*
4101971bd63SSeongJae Park * Converts a string into an struct pid pointers array
4111971bd63SSeongJae Park *
4121971bd63SSeongJae Park * Returns an array of struct pid pointers if the conversion success, or NULL
4131971bd63SSeongJae Park * otherwise.
4141971bd63SSeongJae Park */
str_to_pids(const char * str,ssize_t len,ssize_t * nr_pids)4151971bd63SSeongJae Park static struct pid **str_to_pids(const char *str, ssize_t len, ssize_t *nr_pids)
4161971bd63SSeongJae Park {
4171971bd63SSeongJae Park int *ints;
4181971bd63SSeongJae Park ssize_t nr_ints;
4191971bd63SSeongJae Park struct pid **pids;
4201971bd63SSeongJae Park
4211971bd63SSeongJae Park *nr_pids = 0;
4221971bd63SSeongJae Park
4231971bd63SSeongJae Park ints = str_to_ints(str, len, &nr_ints);
4241971bd63SSeongJae Park if (!ints)
4251971bd63SSeongJae Park return NULL;
4261971bd63SSeongJae Park
4271971bd63SSeongJae Park pids = kmalloc_array(nr_ints, sizeof(*pids), GFP_KERNEL);
4281971bd63SSeongJae Park if (!pids)
4291971bd63SSeongJae Park goto out;
4301971bd63SSeongJae Park
4311971bd63SSeongJae Park for (; *nr_pids < nr_ints; (*nr_pids)++) {
4321971bd63SSeongJae Park pids[*nr_pids] = find_get_pid(ints[*nr_pids]);
4331971bd63SSeongJae Park if (!pids[*nr_pids]) {
4341971bd63SSeongJae Park dbgfs_put_pids(pids, *nr_pids);
4351971bd63SSeongJae Park kfree(ints);
4361971bd63SSeongJae Park kfree(pids);
4371971bd63SSeongJae Park return NULL;
4381971bd63SSeongJae Park }
4391971bd63SSeongJae Park }
4401971bd63SSeongJae Park
4411971bd63SSeongJae Park out:
4421971bd63SSeongJae Park kfree(ints);
4431971bd63SSeongJae Park return pids;
4444bc05954SSeongJae Park }
4454bc05954SSeongJae Park
44643642825SSeongJae Park /*
44743642825SSeongJae Park * dbgfs_set_targets() - Set monitoring targets.
44843642825SSeongJae Park * @ctx: monitoring context
4491971bd63SSeongJae Park * @nr_targets: number of targets
4501971bd63SSeongJae Park * @pids: array of target pids (size is same to @nr_targets)
45143642825SSeongJae Park *
4521971bd63SSeongJae Park * This function should not be called while the kdamond is running. @pids is
4531971bd63SSeongJae Park * ignored if the context is not configured to have pid in each target. On
4541971bd63SSeongJae Park * failure, reference counts of all pids in @pids are decremented.
45543642825SSeongJae Park *
45643642825SSeongJae Park * Return: 0 on success, negative error code otherwise.
45743642825SSeongJae Park */
dbgfs_set_targets(struct damon_ctx * ctx,ssize_t nr_targets,struct pid ** pids)4581971bd63SSeongJae Park static int dbgfs_set_targets(struct damon_ctx *ctx, ssize_t nr_targets,
4591971bd63SSeongJae Park struct pid **pids)
46043642825SSeongJae Park {
46143642825SSeongJae Park ssize_t i;
46243642825SSeongJae Park struct damon_target *t, *next;
46343642825SSeongJae Park
46443642825SSeongJae Park damon_for_each_target_safe(t, next, ctx) {
465c9e124e0SSeongJae Park if (damon_target_has_pid(ctx))
4661971bd63SSeongJae Park put_pid(t->pid);
46743642825SSeongJae Park damon_destroy_target(t);
46843642825SSeongJae Park }
46943642825SSeongJae Park
4701971bd63SSeongJae Park for (i = 0; i < nr_targets; i++) {
4711971bd63SSeongJae Park t = damon_new_target();
47243642825SSeongJae Park if (!t) {
47343642825SSeongJae Park damon_for_each_target_safe(t, next, ctx)
47443642825SSeongJae Park damon_destroy_target(t);
475c9e124e0SSeongJae Park if (damon_target_has_pid(ctx))
4761971bd63SSeongJae Park dbgfs_put_pids(pids, nr_targets);
47743642825SSeongJae Park return -ENOMEM;
47843642825SSeongJae Park }
479c9e124e0SSeongJae Park if (damon_target_has_pid(ctx))
4801971bd63SSeongJae Park t->pid = pids[i];
48143642825SSeongJae Park damon_add_target(ctx, t);
48243642825SSeongJae Park }
48343642825SSeongJae Park
48443642825SSeongJae Park return 0;
48543642825SSeongJae Park }
48643642825SSeongJae Park
dbgfs_target_ids_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)4874bc05954SSeongJae Park static ssize_t dbgfs_target_ids_write(struct file *file,
4884bc05954SSeongJae Park const char __user *buf, size_t count, loff_t *ppos)
4894bc05954SSeongJae Park {
4904bc05954SSeongJae Park struct damon_ctx *ctx = file->private_data;
491c026291aSSeongJae Park bool id_is_pid = true;
49270b84808SSeongJae Park char *kbuf;
4931971bd63SSeongJae Park struct pid **target_pids = NULL;
4944bc05954SSeongJae Park ssize_t nr_targets;
4959210622aSRongwei Wang ssize_t ret;
4964bc05954SSeongJae Park
4974bc05954SSeongJae Park kbuf = user_input_str(buf, count, ppos);
4984bc05954SSeongJae Park if (IS_ERR(kbuf))
4994bc05954SSeongJae Park return PTR_ERR(kbuf);
5004bc05954SSeongJae Park
501c026291aSSeongJae Park if (!strncmp(kbuf, "paddr\n", count)) {
502c026291aSSeongJae Park id_is_pid = false;
5031971bd63SSeongJae Park nr_targets = 1;
5044bc05954SSeongJae Park }
5054bc05954SSeongJae Park
506c026291aSSeongJae Park if (id_is_pid) {
5071971bd63SSeongJae Park target_pids = str_to_pids(kbuf, count, &nr_targets);
5081971bd63SSeongJae Park if (!target_pids) {
5091971bd63SSeongJae Park ret = -ENOMEM;
5101971bd63SSeongJae Park goto out;
5114bc05954SSeongJae Park }
5124bc05954SSeongJae Park }
5134bc05954SSeongJae Park
5144bc05954SSeongJae Park mutex_lock(&ctx->kdamond_lock);
5154bc05954SSeongJae Park if (ctx->kdamond) {
516c026291aSSeongJae Park if (id_is_pid)
5171971bd63SSeongJae Park dbgfs_put_pids(target_pids, nr_targets);
5184bc05954SSeongJae Park ret = -EBUSY;
5194bc05954SSeongJae Park goto unlock_out;
5204bc05954SSeongJae Park }
5214bc05954SSeongJae Park
522ebb3f994SSeongJae Park /* remove previously set targets */
5231971bd63SSeongJae Park dbgfs_set_targets(ctx, 0, NULL);
524da7aaca0SSeongJae Park if (!nr_targets) {
525da7aaca0SSeongJae Park ret = count;
526da7aaca0SSeongJae Park goto unlock_out;
527da7aaca0SSeongJae Park }
528c026291aSSeongJae Park
529c026291aSSeongJae Park /* Configure the context for the address space type */
530c026291aSSeongJae Park if (id_is_pid)
531da7aaca0SSeongJae Park ret = damon_select_ops(ctx, DAMON_OPS_VADDR);
532c026291aSSeongJae Park else
533da7aaca0SSeongJae Park ret = damon_select_ops(ctx, DAMON_OPS_PADDR);
534da7aaca0SSeongJae Park if (ret)
535da7aaca0SSeongJae Park goto unlock_out;
536c026291aSSeongJae Park
5371971bd63SSeongJae Park ret = dbgfs_set_targets(ctx, nr_targets, target_pids);
53843642825SSeongJae Park if (!ret)
5399210622aSRongwei Wang ret = count;
5404bc05954SSeongJae Park
5414bc05954SSeongJae Park unlock_out:
5424bc05954SSeongJae Park mutex_unlock(&ctx->kdamond_lock);
5431971bd63SSeongJae Park kfree(target_pids);
5444bc05954SSeongJae Park out:
5454bc05954SSeongJae Park kfree(kbuf);
5464bc05954SSeongJae Park return ret;
5474bc05954SSeongJae Park }
5484bc05954SSeongJae Park
sprint_init_regions(struct damon_ctx * c,char * buf,ssize_t len)54990bebce9SSeongJae Park static ssize_t sprint_init_regions(struct damon_ctx *c, char *buf, ssize_t len)
55090bebce9SSeongJae Park {
55190bebce9SSeongJae Park struct damon_target *t;
55290bebce9SSeongJae Park struct damon_region *r;
553144760f8SSeongJae Park int target_idx = 0;
55490bebce9SSeongJae Park int written = 0;
55590bebce9SSeongJae Park int rc;
55690bebce9SSeongJae Park
55790bebce9SSeongJae Park damon_for_each_target(t, c) {
55890bebce9SSeongJae Park damon_for_each_region(r, t) {
55990bebce9SSeongJae Park rc = scnprintf(&buf[written], len - written,
560144760f8SSeongJae Park "%d %lu %lu\n",
561144760f8SSeongJae Park target_idx, r->ar.start, r->ar.end);
56290bebce9SSeongJae Park if (!rc)
56390bebce9SSeongJae Park return -ENOMEM;
56490bebce9SSeongJae Park written += rc;
56590bebce9SSeongJae Park }
566144760f8SSeongJae Park target_idx++;
56790bebce9SSeongJae Park }
56890bebce9SSeongJae Park return written;
56990bebce9SSeongJae Park }
57090bebce9SSeongJae Park
dbgfs_init_regions_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)57190bebce9SSeongJae Park static ssize_t dbgfs_init_regions_read(struct file *file, char __user *buf,
57290bebce9SSeongJae Park size_t count, loff_t *ppos)
57390bebce9SSeongJae Park {
57490bebce9SSeongJae Park struct damon_ctx *ctx = file->private_data;
57590bebce9SSeongJae Park char *kbuf;
57690bebce9SSeongJae Park ssize_t len;
57790bebce9SSeongJae Park
578db7a347bSSeongJae Park kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN);
57990bebce9SSeongJae Park if (!kbuf)
58090bebce9SSeongJae Park return -ENOMEM;
58190bebce9SSeongJae Park
58290bebce9SSeongJae Park mutex_lock(&ctx->kdamond_lock);
58390bebce9SSeongJae Park if (ctx->kdamond) {
58490bebce9SSeongJae Park mutex_unlock(&ctx->kdamond_lock);
58590bebce9SSeongJae Park len = -EBUSY;
58690bebce9SSeongJae Park goto out;
58790bebce9SSeongJae Park }
58890bebce9SSeongJae Park
58990bebce9SSeongJae Park len = sprint_init_regions(ctx, kbuf, count);
59090bebce9SSeongJae Park mutex_unlock(&ctx->kdamond_lock);
59190bebce9SSeongJae Park if (len < 0)
59290bebce9SSeongJae Park goto out;
59390bebce9SSeongJae Park len = simple_read_from_buffer(buf, count, ppos, kbuf, len);
59490bebce9SSeongJae Park
59590bebce9SSeongJae Park out:
59690bebce9SSeongJae Park kfree(kbuf);
59790bebce9SSeongJae Park return len;
59890bebce9SSeongJae Park }
59990bebce9SSeongJae Park
add_init_region(struct damon_ctx * c,int target_idx,struct damon_addr_range * ar)600144760f8SSeongJae Park static int add_init_region(struct damon_ctx *c, int target_idx,
601144760f8SSeongJae Park struct damon_addr_range *ar)
60290bebce9SSeongJae Park {
60390bebce9SSeongJae Park struct damon_target *t;
60490bebce9SSeongJae Park struct damon_region *r, *prev;
605144760f8SSeongJae Park unsigned long idx = 0;
60690bebce9SSeongJae Park int rc = -EINVAL;
60790bebce9SSeongJae Park
60890bebce9SSeongJae Park if (ar->start >= ar->end)
60990bebce9SSeongJae Park return -EINVAL;
61090bebce9SSeongJae Park
61190bebce9SSeongJae Park damon_for_each_target(t, c) {
612144760f8SSeongJae Park if (idx++ == target_idx) {
61390bebce9SSeongJae Park r = damon_new_region(ar->start, ar->end);
61490bebce9SSeongJae Park if (!r)
61590bebce9SSeongJae Park return -ENOMEM;
61690bebce9SSeongJae Park damon_add_region(r, t);
61790bebce9SSeongJae Park if (damon_nr_regions(t) > 1) {
61890bebce9SSeongJae Park prev = damon_prev_region(r);
61990bebce9SSeongJae Park if (prev->ar.end > r->ar.start) {
62090bebce9SSeongJae Park damon_destroy_region(r, t);
62190bebce9SSeongJae Park return -EINVAL;
62290bebce9SSeongJae Park }
62390bebce9SSeongJae Park }
62490bebce9SSeongJae Park rc = 0;
62590bebce9SSeongJae Park }
62690bebce9SSeongJae Park }
62790bebce9SSeongJae Park return rc;
62890bebce9SSeongJae Park }
62990bebce9SSeongJae Park
set_init_regions(struct damon_ctx * c,const char * str,ssize_t len)63090bebce9SSeongJae Park static int set_init_regions(struct damon_ctx *c, const char *str, ssize_t len)
63190bebce9SSeongJae Park {
63290bebce9SSeongJae Park struct damon_target *t;
63390bebce9SSeongJae Park struct damon_region *r, *next;
63490bebce9SSeongJae Park int pos = 0, parsed, ret;
635144760f8SSeongJae Park int target_idx;
63690bebce9SSeongJae Park struct damon_addr_range ar;
63790bebce9SSeongJae Park int err;
63890bebce9SSeongJae Park
63990bebce9SSeongJae Park damon_for_each_target(t, c) {
64090bebce9SSeongJae Park damon_for_each_region_safe(r, next, t)
64190bebce9SSeongJae Park damon_destroy_region(r, t);
64290bebce9SSeongJae Park }
64390bebce9SSeongJae Park
64490bebce9SSeongJae Park while (pos < len) {
645144760f8SSeongJae Park ret = sscanf(&str[pos], "%d %lu %lu%n",
646144760f8SSeongJae Park &target_idx, &ar.start, &ar.end, &parsed);
64790bebce9SSeongJae Park if (ret != 3)
64890bebce9SSeongJae Park break;
649144760f8SSeongJae Park err = add_init_region(c, target_idx, &ar);
65090bebce9SSeongJae Park if (err)
65190bebce9SSeongJae Park goto fail;
65290bebce9SSeongJae Park pos += parsed;
65390bebce9SSeongJae Park }
65490bebce9SSeongJae Park
65590bebce9SSeongJae Park return 0;
65690bebce9SSeongJae Park
65790bebce9SSeongJae Park fail:
65890bebce9SSeongJae Park damon_for_each_target(t, c) {
65990bebce9SSeongJae Park damon_for_each_region_safe(r, next, t)
66090bebce9SSeongJae Park damon_destroy_region(r, t);
66190bebce9SSeongJae Park }
66290bebce9SSeongJae Park return err;
66390bebce9SSeongJae Park }
66490bebce9SSeongJae Park
dbgfs_init_regions_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)66590bebce9SSeongJae Park static ssize_t dbgfs_init_regions_write(struct file *file,
66690bebce9SSeongJae Park const char __user *buf, size_t count,
66790bebce9SSeongJae Park loff_t *ppos)
66890bebce9SSeongJae Park {
66990bebce9SSeongJae Park struct damon_ctx *ctx = file->private_data;
67090bebce9SSeongJae Park char *kbuf;
67190bebce9SSeongJae Park ssize_t ret = count;
67290bebce9SSeongJae Park int err;
67390bebce9SSeongJae Park
67490bebce9SSeongJae Park kbuf = user_input_str(buf, count, ppos);
67590bebce9SSeongJae Park if (IS_ERR(kbuf))
67690bebce9SSeongJae Park return PTR_ERR(kbuf);
67790bebce9SSeongJae Park
67890bebce9SSeongJae Park mutex_lock(&ctx->kdamond_lock);
67990bebce9SSeongJae Park if (ctx->kdamond) {
68090bebce9SSeongJae Park ret = -EBUSY;
68190bebce9SSeongJae Park goto unlock_out;
68290bebce9SSeongJae Park }
68390bebce9SSeongJae Park
68490bebce9SSeongJae Park err = set_init_regions(ctx, kbuf, ret);
68590bebce9SSeongJae Park if (err)
68690bebce9SSeongJae Park ret = err;
68790bebce9SSeongJae Park
68890bebce9SSeongJae Park unlock_out:
68990bebce9SSeongJae Park mutex_unlock(&ctx->kdamond_lock);
69090bebce9SSeongJae Park kfree(kbuf);
69190bebce9SSeongJae Park return ret;
69290bebce9SSeongJae Park }
69390bebce9SSeongJae Park
dbgfs_kdamond_pid_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)694429538e8SSeongJae Park static ssize_t dbgfs_kdamond_pid_read(struct file *file,
695429538e8SSeongJae Park char __user *buf, size_t count, loff_t *ppos)
696429538e8SSeongJae Park {
697429538e8SSeongJae Park struct damon_ctx *ctx = file->private_data;
698429538e8SSeongJae Park char *kbuf;
699429538e8SSeongJae Park ssize_t len;
700429538e8SSeongJae Park
701db7a347bSSeongJae Park kbuf = kmalloc(count, GFP_KERNEL | __GFP_NOWARN);
702429538e8SSeongJae Park if (!kbuf)
703429538e8SSeongJae Park return -ENOMEM;
704429538e8SSeongJae Park
705429538e8SSeongJae Park mutex_lock(&ctx->kdamond_lock);
706429538e8SSeongJae Park if (ctx->kdamond)
707429538e8SSeongJae Park len = scnprintf(kbuf, count, "%d\n", ctx->kdamond->pid);
708429538e8SSeongJae Park else
709429538e8SSeongJae Park len = scnprintf(kbuf, count, "none\n");
710429538e8SSeongJae Park mutex_unlock(&ctx->kdamond_lock);
711429538e8SSeongJae Park if (!len)
712429538e8SSeongJae Park goto out;
713429538e8SSeongJae Park len = simple_read_from_buffer(buf, count, ppos, kbuf, len);
714429538e8SSeongJae Park
715429538e8SSeongJae Park out:
716429538e8SSeongJae Park kfree(kbuf);
717429538e8SSeongJae Park return len;
718429538e8SSeongJae Park }
719429538e8SSeongJae Park
damon_dbgfs_open(struct inode * inode,struct file * file)7204bc05954SSeongJae Park static int damon_dbgfs_open(struct inode *inode, struct file *file)
7214bc05954SSeongJae Park {
722*620932cdSSeongJae Park damon_dbgfs_warn_deprecation();
723*620932cdSSeongJae Park
7244bc05954SSeongJae Park file->private_data = inode->i_private;
7254bc05954SSeongJae Park
7264bc05954SSeongJae Park return nonseekable_open(inode, file);
7274bc05954SSeongJae Park }
7284bc05954SSeongJae Park
7294bc05954SSeongJae Park static const struct file_operations attrs_fops = {
7304bc05954SSeongJae Park .open = damon_dbgfs_open,
7314bc05954SSeongJae Park .read = dbgfs_attrs_read,
7324bc05954SSeongJae Park .write = dbgfs_attrs_write,
7334bc05954SSeongJae Park };
7344bc05954SSeongJae Park
735af122dd8SSeongJae Park static const struct file_operations schemes_fops = {
736af122dd8SSeongJae Park .open = damon_dbgfs_open,
737af122dd8SSeongJae Park .read = dbgfs_schemes_read,
738af122dd8SSeongJae Park .write = dbgfs_schemes_write,
739af122dd8SSeongJae Park };
740af122dd8SSeongJae Park
7414bc05954SSeongJae Park static const struct file_operations target_ids_fops = {
7424bc05954SSeongJae Park .open = damon_dbgfs_open,
7434bc05954SSeongJae Park .read = dbgfs_target_ids_read,
7444bc05954SSeongJae Park .write = dbgfs_target_ids_write,
7454bc05954SSeongJae Park };
7464bc05954SSeongJae Park
74790bebce9SSeongJae Park static const struct file_operations init_regions_fops = {
74890bebce9SSeongJae Park .open = damon_dbgfs_open,
74990bebce9SSeongJae Park .read = dbgfs_init_regions_read,
75090bebce9SSeongJae Park .write = dbgfs_init_regions_write,
75190bebce9SSeongJae Park };
75290bebce9SSeongJae Park
753429538e8SSeongJae Park static const struct file_operations kdamond_pid_fops = {
754429538e8SSeongJae Park .open = damon_dbgfs_open,
755429538e8SSeongJae Park .read = dbgfs_kdamond_pid_read,
756429538e8SSeongJae Park };
757429538e8SSeongJae Park
dbgfs_fill_ctx_dir(struct dentry * dir,struct damon_ctx * ctx)7584bc05954SSeongJae Park static void dbgfs_fill_ctx_dir(struct dentry *dir, struct damon_ctx *ctx)
7594bc05954SSeongJae Park {
760af122dd8SSeongJae Park const char * const file_names[] = {"attrs", "schemes", "target_ids",
76190bebce9SSeongJae Park "init_regions", "kdamond_pid"};
762af122dd8SSeongJae Park const struct file_operations *fops[] = {&attrs_fops, &schemes_fops,
76390bebce9SSeongJae Park &target_ids_fops, &init_regions_fops, &kdamond_pid_fops};
7644bc05954SSeongJae Park int i;
7654bc05954SSeongJae Park
7664bc05954SSeongJae Park for (i = 0; i < ARRAY_SIZE(file_names); i++)
7674bc05954SSeongJae Park debugfs_create_file(file_names[i], 0600, dir, ctx, fops[i]);
7684bc05954SSeongJae Park }
7694bc05954SSeongJae Park
dbgfs_before_terminate(struct damon_ctx * ctx)770658f9ae7SChangbin Du static void dbgfs_before_terminate(struct damon_ctx *ctx)
7714bc05954SSeongJae Park {
7724bc05954SSeongJae Park struct damon_target *t, *next;
7734bc05954SSeongJae Park
774c9e124e0SSeongJae Park if (!damon_target_has_pid(ctx))
775658f9ae7SChangbin Du return;
7764bc05954SSeongJae Park
77734796417SSeongJae Park mutex_lock(&ctx->kdamond_lock);
7784bc05954SSeongJae Park damon_for_each_target_safe(t, next, ctx) {
7791971bd63SSeongJae Park put_pid(t->pid);
7804bc05954SSeongJae Park damon_destroy_target(t);
7814bc05954SSeongJae Park }
78234796417SSeongJae Park mutex_unlock(&ctx->kdamond_lock);
7834bc05954SSeongJae Park }
7844bc05954SSeongJae Park
dbgfs_new_ctx(void)7854bc05954SSeongJae Park static struct damon_ctx *dbgfs_new_ctx(void)
7864bc05954SSeongJae Park {
7874bc05954SSeongJae Park struct damon_ctx *ctx;
7884bc05954SSeongJae Park
7894bc05954SSeongJae Park ctx = damon_new_ctx();
7904bc05954SSeongJae Park if (!ctx)
7914bc05954SSeongJae Park return NULL;
7924bc05954SSeongJae Park
7934a20865bSSeongJae Park if (damon_select_ops(ctx, DAMON_OPS_VADDR) &&
7944a20865bSSeongJae Park damon_select_ops(ctx, DAMON_OPS_PADDR)) {
795da7aaca0SSeongJae Park damon_destroy_ctx(ctx);
796da7aaca0SSeongJae Park return NULL;
797da7aaca0SSeongJae Park }
7984bc05954SSeongJae Park ctx->callback.before_terminate = dbgfs_before_terminate;
7994bc05954SSeongJae Park return ctx;
8004bc05954SSeongJae Park }
8014bc05954SSeongJae Park
dbgfs_destroy_ctx(struct damon_ctx * ctx)80275c1c2b5SSeongJae Park static void dbgfs_destroy_ctx(struct damon_ctx *ctx)
80375c1c2b5SSeongJae Park {
80475c1c2b5SSeongJae Park damon_destroy_ctx(ctx);
80575c1c2b5SSeongJae Park }
80675c1c2b5SSeongJae Park
80775c1c2b5SSeongJae Park /*
80875c1c2b5SSeongJae Park * Make a context of @name and create a debugfs directory for it.
80975c1c2b5SSeongJae Park *
81075c1c2b5SSeongJae Park * This function should be called while holding damon_dbgfs_lock.
81175c1c2b5SSeongJae Park *
81275c1c2b5SSeongJae Park * Returns 0 on success, negative error code otherwise.
81375c1c2b5SSeongJae Park */
dbgfs_mk_context(char * name)81475c1c2b5SSeongJae Park static int dbgfs_mk_context(char *name)
81575c1c2b5SSeongJae Park {
81675c1c2b5SSeongJae Park struct dentry *root, **new_dirs, *new_dir;
81775c1c2b5SSeongJae Park struct damon_ctx **new_ctxs, *new_ctx;
81875c1c2b5SSeongJae Park
81975c1c2b5SSeongJae Park if (damon_nr_running_ctxs())
82075c1c2b5SSeongJae Park return -EBUSY;
82175c1c2b5SSeongJae Park
82275c1c2b5SSeongJae Park new_ctxs = krealloc(dbgfs_ctxs, sizeof(*dbgfs_ctxs) *
82375c1c2b5SSeongJae Park (dbgfs_nr_ctxs + 1), GFP_KERNEL);
82475c1c2b5SSeongJae Park if (!new_ctxs)
82575c1c2b5SSeongJae Park return -ENOMEM;
82675c1c2b5SSeongJae Park dbgfs_ctxs = new_ctxs;
82775c1c2b5SSeongJae Park
82875c1c2b5SSeongJae Park new_dirs = krealloc(dbgfs_dirs, sizeof(*dbgfs_dirs) *
82975c1c2b5SSeongJae Park (dbgfs_nr_ctxs + 1), GFP_KERNEL);
83075c1c2b5SSeongJae Park if (!new_dirs)
83175c1c2b5SSeongJae Park return -ENOMEM;
83275c1c2b5SSeongJae Park dbgfs_dirs = new_dirs;
83375c1c2b5SSeongJae Park
83475c1c2b5SSeongJae Park root = dbgfs_dirs[0];
83575c1c2b5SSeongJae Park if (!root)
83675c1c2b5SSeongJae Park return -ENOENT;
83775c1c2b5SSeongJae Park
83875c1c2b5SSeongJae Park new_dir = debugfs_create_dir(name, root);
839d26f6070SBadari Pulavarty /* Below check is required for a potential duplicated name case */
840d26f6070SBadari Pulavarty if (IS_ERR(new_dir))
841d26f6070SBadari Pulavarty return PTR_ERR(new_dir);
84275c1c2b5SSeongJae Park dbgfs_dirs[dbgfs_nr_ctxs] = new_dir;
84375c1c2b5SSeongJae Park
84475c1c2b5SSeongJae Park new_ctx = dbgfs_new_ctx();
84575c1c2b5SSeongJae Park if (!new_ctx) {
84675c1c2b5SSeongJae Park debugfs_remove(new_dir);
84775c1c2b5SSeongJae Park dbgfs_dirs[dbgfs_nr_ctxs] = NULL;
84875c1c2b5SSeongJae Park return -ENOMEM;
84975c1c2b5SSeongJae Park }
85075c1c2b5SSeongJae Park
85175c1c2b5SSeongJae Park dbgfs_ctxs[dbgfs_nr_ctxs] = new_ctx;
85275c1c2b5SSeongJae Park dbgfs_fill_ctx_dir(dbgfs_dirs[dbgfs_nr_ctxs],
85375c1c2b5SSeongJae Park dbgfs_ctxs[dbgfs_nr_ctxs]);
85475c1c2b5SSeongJae Park dbgfs_nr_ctxs++;
85575c1c2b5SSeongJae Park
85675c1c2b5SSeongJae Park return 0;
85775c1c2b5SSeongJae Park }
85875c1c2b5SSeongJae Park
dbgfs_mk_context_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)85975c1c2b5SSeongJae Park static ssize_t dbgfs_mk_context_write(struct file *file,
86075c1c2b5SSeongJae Park const char __user *buf, size_t count, loff_t *ppos)
86175c1c2b5SSeongJae Park {
86275c1c2b5SSeongJae Park char *kbuf;
86375c1c2b5SSeongJae Park char *ctx_name;
8649210622aSRongwei Wang ssize_t ret;
86575c1c2b5SSeongJae Park
86675c1c2b5SSeongJae Park kbuf = user_input_str(buf, count, ppos);
86775c1c2b5SSeongJae Park if (IS_ERR(kbuf))
86875c1c2b5SSeongJae Park return PTR_ERR(kbuf);
86975c1c2b5SSeongJae Park ctx_name = kmalloc(count + 1, GFP_KERNEL);
87075c1c2b5SSeongJae Park if (!ctx_name) {
87175c1c2b5SSeongJae Park kfree(kbuf);
87275c1c2b5SSeongJae Park return -ENOMEM;
87375c1c2b5SSeongJae Park }
87475c1c2b5SSeongJae Park
87575c1c2b5SSeongJae Park /* Trim white space */
87675c1c2b5SSeongJae Park if (sscanf(kbuf, "%s", ctx_name) != 1) {
87775c1c2b5SSeongJae Park ret = -EINVAL;
87875c1c2b5SSeongJae Park goto out;
87975c1c2b5SSeongJae Park }
88075c1c2b5SSeongJae Park
88175c1c2b5SSeongJae Park mutex_lock(&damon_dbgfs_lock);
8829210622aSRongwei Wang ret = dbgfs_mk_context(ctx_name);
8839210622aSRongwei Wang if (!ret)
8849210622aSRongwei Wang ret = count;
88575c1c2b5SSeongJae Park mutex_unlock(&damon_dbgfs_lock);
88675c1c2b5SSeongJae Park
88775c1c2b5SSeongJae Park out:
88875c1c2b5SSeongJae Park kfree(kbuf);
88975c1c2b5SSeongJae Park kfree(ctx_name);
89075c1c2b5SSeongJae Park return ret;
89175c1c2b5SSeongJae Park }
89275c1c2b5SSeongJae Park
89375c1c2b5SSeongJae Park /*
89475c1c2b5SSeongJae Park * Remove a context of @name and its debugfs directory.
89575c1c2b5SSeongJae Park *
89675c1c2b5SSeongJae Park * This function should be called while holding damon_dbgfs_lock.
89775c1c2b5SSeongJae Park *
89875c1c2b5SSeongJae Park * Return 0 on success, negative error code otherwise.
89975c1c2b5SSeongJae Park */
dbgfs_rm_context(char * name)90075c1c2b5SSeongJae Park static int dbgfs_rm_context(char *name)
90175c1c2b5SSeongJae Park {
90275c1c2b5SSeongJae Park struct dentry *root, *dir, **new_dirs;
9031de09a72SSeongJae Park struct inode *inode;
90475c1c2b5SSeongJae Park struct damon_ctx **new_ctxs;
90575c1c2b5SSeongJae Park int i, j;
9061552fd3eSGreg Kroah-Hartman int ret = 0;
90775c1c2b5SSeongJae Park
90875c1c2b5SSeongJae Park if (damon_nr_running_ctxs())
90975c1c2b5SSeongJae Park return -EBUSY;
91075c1c2b5SSeongJae Park
91175c1c2b5SSeongJae Park root = dbgfs_dirs[0];
91275c1c2b5SSeongJae Park if (!root)
91375c1c2b5SSeongJae Park return -ENOENT;
91475c1c2b5SSeongJae Park
91575c1c2b5SSeongJae Park dir = debugfs_lookup(name, root);
91675c1c2b5SSeongJae Park if (!dir)
91775c1c2b5SSeongJae Park return -ENOENT;
91875c1c2b5SSeongJae Park
9191de09a72SSeongJae Park inode = d_inode(dir);
9201de09a72SSeongJae Park if (!S_ISDIR(inode->i_mode)) {
9211de09a72SSeongJae Park ret = -EINVAL;
9221de09a72SSeongJae Park goto out_dput;
9231de09a72SSeongJae Park }
9241de09a72SSeongJae Park
92575c1c2b5SSeongJae Park new_dirs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_dirs),
92675c1c2b5SSeongJae Park GFP_KERNEL);
9271552fd3eSGreg Kroah-Hartman if (!new_dirs) {
9281552fd3eSGreg Kroah-Hartman ret = -ENOMEM;
9291552fd3eSGreg Kroah-Hartman goto out_dput;
9301552fd3eSGreg Kroah-Hartman }
93175c1c2b5SSeongJae Park
93275c1c2b5SSeongJae Park new_ctxs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_ctxs),
93375c1c2b5SSeongJae Park GFP_KERNEL);
93475c1c2b5SSeongJae Park if (!new_ctxs) {
9351552fd3eSGreg Kroah-Hartman ret = -ENOMEM;
9361552fd3eSGreg Kroah-Hartman goto out_new_dirs;
93775c1c2b5SSeongJae Park }
93875c1c2b5SSeongJae Park
93975c1c2b5SSeongJae Park for (i = 0, j = 0; i < dbgfs_nr_ctxs; i++) {
94075c1c2b5SSeongJae Park if (dbgfs_dirs[i] == dir) {
94175c1c2b5SSeongJae Park debugfs_remove(dbgfs_dirs[i]);
94275c1c2b5SSeongJae Park dbgfs_destroy_ctx(dbgfs_ctxs[i]);
94375c1c2b5SSeongJae Park continue;
94475c1c2b5SSeongJae Park }
94575c1c2b5SSeongJae Park new_dirs[j] = dbgfs_dirs[i];
94675c1c2b5SSeongJae Park new_ctxs[j++] = dbgfs_ctxs[i];
94775c1c2b5SSeongJae Park }
94875c1c2b5SSeongJae Park
94975c1c2b5SSeongJae Park kfree(dbgfs_dirs);
95075c1c2b5SSeongJae Park kfree(dbgfs_ctxs);
95175c1c2b5SSeongJae Park
95275c1c2b5SSeongJae Park dbgfs_dirs = new_dirs;
95375c1c2b5SSeongJae Park dbgfs_ctxs = new_ctxs;
95475c1c2b5SSeongJae Park dbgfs_nr_ctxs--;
95575c1c2b5SSeongJae Park
9561552fd3eSGreg Kroah-Hartman goto out_dput;
9571552fd3eSGreg Kroah-Hartman
9581552fd3eSGreg Kroah-Hartman out_new_dirs:
9591552fd3eSGreg Kroah-Hartman kfree(new_dirs);
9601552fd3eSGreg Kroah-Hartman out_dput:
9611552fd3eSGreg Kroah-Hartman dput(dir);
9621552fd3eSGreg Kroah-Hartman return ret;
96375c1c2b5SSeongJae Park }
96475c1c2b5SSeongJae Park
dbgfs_rm_context_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)96575c1c2b5SSeongJae Park static ssize_t dbgfs_rm_context_write(struct file *file,
96675c1c2b5SSeongJae Park const char __user *buf, size_t count, loff_t *ppos)
96775c1c2b5SSeongJae Park {
96875c1c2b5SSeongJae Park char *kbuf;
9699210622aSRongwei Wang ssize_t ret;
97075c1c2b5SSeongJae Park char *ctx_name;
97175c1c2b5SSeongJae Park
97275c1c2b5SSeongJae Park kbuf = user_input_str(buf, count, ppos);
97375c1c2b5SSeongJae Park if (IS_ERR(kbuf))
97475c1c2b5SSeongJae Park return PTR_ERR(kbuf);
97575c1c2b5SSeongJae Park ctx_name = kmalloc(count + 1, GFP_KERNEL);
97675c1c2b5SSeongJae Park if (!ctx_name) {
97775c1c2b5SSeongJae Park kfree(kbuf);
97875c1c2b5SSeongJae Park return -ENOMEM;
97975c1c2b5SSeongJae Park }
98075c1c2b5SSeongJae Park
98175c1c2b5SSeongJae Park /* Trim white space */
98275c1c2b5SSeongJae Park if (sscanf(kbuf, "%s", ctx_name) != 1) {
98375c1c2b5SSeongJae Park ret = -EINVAL;
98475c1c2b5SSeongJae Park goto out;
98575c1c2b5SSeongJae Park }
98675c1c2b5SSeongJae Park
98775c1c2b5SSeongJae Park mutex_lock(&damon_dbgfs_lock);
9889210622aSRongwei Wang ret = dbgfs_rm_context(ctx_name);
9899210622aSRongwei Wang if (!ret)
9909210622aSRongwei Wang ret = count;
99175c1c2b5SSeongJae Park mutex_unlock(&damon_dbgfs_lock);
99275c1c2b5SSeongJae Park
99375c1c2b5SSeongJae Park out:
99475c1c2b5SSeongJae Park kfree(kbuf);
99575c1c2b5SSeongJae Park kfree(ctx_name);
99675c1c2b5SSeongJae Park return ret;
99775c1c2b5SSeongJae Park }
99875c1c2b5SSeongJae Park
dbgfs_monitor_on_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)9994bc05954SSeongJae Park static ssize_t dbgfs_monitor_on_read(struct file *file,
10004bc05954SSeongJae Park char __user *buf, size_t count, loff_t *ppos)
10014bc05954SSeongJae Park {
10024bc05954SSeongJae Park char monitor_on_buf[5];
10034bc05954SSeongJae Park bool monitor_on = damon_nr_running_ctxs() != 0;
10044bc05954SSeongJae Park int len;
10054bc05954SSeongJae Park
10064bc05954SSeongJae Park len = scnprintf(monitor_on_buf, 5, monitor_on ? "on\n" : "off\n");
10074bc05954SSeongJae Park
10084bc05954SSeongJae Park return simple_read_from_buffer(buf, count, ppos, monitor_on_buf, len);
10094bc05954SSeongJae Park }
10104bc05954SSeongJae Park
dbgfs_monitor_on_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)10114bc05954SSeongJae Park static ssize_t dbgfs_monitor_on_write(struct file *file,
10124bc05954SSeongJae Park const char __user *buf, size_t count, loff_t *ppos)
10134bc05954SSeongJae Park {
10149210622aSRongwei Wang ssize_t ret;
10154bc05954SSeongJae Park char *kbuf;
10164bc05954SSeongJae Park
10174bc05954SSeongJae Park kbuf = user_input_str(buf, count, ppos);
10184bc05954SSeongJae Park if (IS_ERR(kbuf))
10194bc05954SSeongJae Park return PTR_ERR(kbuf);
10204bc05954SSeongJae Park
10214bc05954SSeongJae Park /* Remove white space */
10224bc05954SSeongJae Park if (sscanf(kbuf, "%s", kbuf) != 1) {
10234bc05954SSeongJae Park kfree(kbuf);
10244bc05954SSeongJae Park return -EINVAL;
10254bc05954SSeongJae Park }
10264bc05954SSeongJae Park
1027d78f3853SSeongJae Park mutex_lock(&damon_dbgfs_lock);
1028b5ca3e83SXin Hao if (!strncmp(kbuf, "on", count)) {
1029b5ca3e83SXin Hao int i;
1030b5ca3e83SXin Hao
1031b5ca3e83SXin Hao for (i = 0; i < dbgfs_nr_ctxs; i++) {
1032b5ca3e83SXin Hao if (damon_targets_empty(dbgfs_ctxs[i])) {
1033b5ca3e83SXin Hao kfree(kbuf);
1034d78f3853SSeongJae Park mutex_unlock(&damon_dbgfs_lock);
1035b5ca3e83SXin Hao return -EINVAL;
1036b5ca3e83SXin Hao }
1037b5ca3e83SXin Hao }
10388b9b0d33SSeongJae Park ret = damon_start(dbgfs_ctxs, dbgfs_nr_ctxs, true);
1039b5ca3e83SXin Hao } else if (!strncmp(kbuf, "off", count)) {
10409210622aSRongwei Wang ret = damon_stop(dbgfs_ctxs, dbgfs_nr_ctxs);
1041b5ca3e83SXin Hao } else {
10429210622aSRongwei Wang ret = -EINVAL;
1043b5ca3e83SXin Hao }
1044d78f3853SSeongJae Park mutex_unlock(&damon_dbgfs_lock);
10454bc05954SSeongJae Park
10469210622aSRongwei Wang if (!ret)
10479210622aSRongwei Wang ret = count;
10484bc05954SSeongJae Park kfree(kbuf);
10494bc05954SSeongJae Park return ret;
10504bc05954SSeongJae Park }
10514bc05954SSeongJae Park
damon_dbgfs_static_file_open(struct inode * inode,struct file * file)1052*620932cdSSeongJae Park static int damon_dbgfs_static_file_open(struct inode *inode, struct file *file)
1053*620932cdSSeongJae Park {
1054*620932cdSSeongJae Park damon_dbgfs_warn_deprecation();
1055*620932cdSSeongJae Park return nonseekable_open(inode, file);
1056*620932cdSSeongJae Park }
1057*620932cdSSeongJae Park
105875c1c2b5SSeongJae Park static const struct file_operations mk_contexts_fops = {
1059*620932cdSSeongJae Park .open = damon_dbgfs_static_file_open,
106075c1c2b5SSeongJae Park .write = dbgfs_mk_context_write,
106175c1c2b5SSeongJae Park };
106275c1c2b5SSeongJae Park
106375c1c2b5SSeongJae Park static const struct file_operations rm_contexts_fops = {
1064*620932cdSSeongJae Park .open = damon_dbgfs_static_file_open,
106575c1c2b5SSeongJae Park .write = dbgfs_rm_context_write,
106675c1c2b5SSeongJae Park };
106775c1c2b5SSeongJae Park
10684bc05954SSeongJae Park static const struct file_operations monitor_on_fops = {
1069*620932cdSSeongJae Park .open = damon_dbgfs_static_file_open,
10704bc05954SSeongJae Park .read = dbgfs_monitor_on_read,
10714bc05954SSeongJae Park .write = dbgfs_monitor_on_write,
10724bc05954SSeongJae Park };
10734bc05954SSeongJae Park
__damon_dbgfs_init(void)10744bc05954SSeongJae Park static int __init __damon_dbgfs_init(void)
10754bc05954SSeongJae Park {
10764bc05954SSeongJae Park struct dentry *dbgfs_root;
107775c1c2b5SSeongJae Park const char * const file_names[] = {"mk_contexts", "rm_contexts",
107875c1c2b5SSeongJae Park "monitor_on"};
107975c1c2b5SSeongJae Park const struct file_operations *fops[] = {&mk_contexts_fops,
108075c1c2b5SSeongJae Park &rm_contexts_fops, &monitor_on_fops};
10814bc05954SSeongJae Park int i;
10824bc05954SSeongJae Park
10834bc05954SSeongJae Park dbgfs_root = debugfs_create_dir("damon", NULL);
10844bc05954SSeongJae Park
10854bc05954SSeongJae Park for (i = 0; i < ARRAY_SIZE(file_names); i++)
10864bc05954SSeongJae Park debugfs_create_file(file_names[i], 0600, dbgfs_root, NULL,
10874bc05954SSeongJae Park fops[i]);
10884bc05954SSeongJae Park dbgfs_fill_ctx_dir(dbgfs_root, dbgfs_ctxs[0]);
10894bc05954SSeongJae Park
1090b2d4c646SKenneth Lee dbgfs_dirs = kmalloc(sizeof(dbgfs_root), GFP_KERNEL);
10914bc05954SSeongJae Park if (!dbgfs_dirs) {
10924bc05954SSeongJae Park debugfs_remove(dbgfs_root);
10934bc05954SSeongJae Park return -ENOMEM;
10944bc05954SSeongJae Park }
10954bc05954SSeongJae Park dbgfs_dirs[0] = dbgfs_root;
10964bc05954SSeongJae Park
10974bc05954SSeongJae Park return 0;
10984bc05954SSeongJae Park }
10994bc05954SSeongJae Park
11004bc05954SSeongJae Park /*
11014bc05954SSeongJae Park * Functions for the initialization
11024bc05954SSeongJae Park */
11034bc05954SSeongJae Park
damon_dbgfs_init(void)11044bc05954SSeongJae Park static int __init damon_dbgfs_init(void)
11054bc05954SSeongJae Park {
1106d78f3853SSeongJae Park int rc = -ENOMEM;
11074bc05954SSeongJae Park
1108d78f3853SSeongJae Park mutex_lock(&damon_dbgfs_lock);
11094bc05954SSeongJae Park dbgfs_ctxs = kmalloc(sizeof(*dbgfs_ctxs), GFP_KERNEL);
11104bc05954SSeongJae Park if (!dbgfs_ctxs)
1111d78f3853SSeongJae Park goto out;
11124bc05954SSeongJae Park dbgfs_ctxs[0] = dbgfs_new_ctx();
11134bc05954SSeongJae Park if (!dbgfs_ctxs[0]) {
11144bc05954SSeongJae Park kfree(dbgfs_ctxs);
1115d78f3853SSeongJae Park goto out;
11164bc05954SSeongJae Park }
11174bc05954SSeongJae Park dbgfs_nr_ctxs = 1;
11184bc05954SSeongJae Park
11194bc05954SSeongJae Park rc = __damon_dbgfs_init();
11204bc05954SSeongJae Park if (rc) {
11214bc05954SSeongJae Park kfree(dbgfs_ctxs[0]);
11224bc05954SSeongJae Park kfree(dbgfs_ctxs);
11234bc05954SSeongJae Park pr_err("%s: dbgfs init failed\n", __func__);
11244bc05954SSeongJae Park }
11254bc05954SSeongJae Park
1126d78f3853SSeongJae Park out:
1127d78f3853SSeongJae Park mutex_unlock(&damon_dbgfs_lock);
11284bc05954SSeongJae Park return rc;
11294bc05954SSeongJae Park }
11304bc05954SSeongJae Park
11314bc05954SSeongJae Park module_init(damon_dbgfs_init);
113217ccae8bSSeongJae Park
113317ccae8bSSeongJae Park #include "dbgfs-test.h"
1134