// SPDX-License-Identifier: GPL-2.0
/*
 * DAMON Debugfs Interface
 *
 * Author: SeongJae Park <sjpark@amazon.de>
 */

#define pr_fmt(fmt) "damon-dbgfs: " fmt

#include <linux/damon.h>
#include <linux/debugfs.h>
#include <linux/file.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/page_idle.h>
#include <linux/slab.h>

static struct damon_ctx **dbgfs_ctxs;
static int dbgfs_nr_ctxs;
static struct dentry **dbgfs_dirs;
static DEFINE_MUTEX(damon_dbgfs_lock);

/*
 * Returns non-empty string on success, negative 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 dbgfs_attrs_read(struct file *file,
                char __user *buf, size_t count, loff_t *ppos)
{
        struct damon_ctx *ctx = file->private_data;
        char kbuf[128];
        int ret;

        mutex_lock(&ctx->kdamond_lock);
        ret = scnprintf(kbuf, ARRAY_SIZE(kbuf), "%lu %lu %lu %lu %lu\n",
                        ctx->sample_interval, ctx->aggr_interval,
                        ctx->primitive_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 dbgfs_attrs_write(struct file *file,
                const char __user *buf, size_t count, loff_t *ppos)
{
        struct damon_ctx *ctx = file->private_data;
        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 inline bool targetid_is_pid(const struct damon_ctx *ctx)
{
        return ctx->primitive.target_valid == damon_va_target_valid;
}

static ssize_t sprint_target_ids(struct damon_ctx *ctx, char *buf, ssize_t len)
{
        struct damon_target *t;
        unsigned long id;
        int written = 0;
        int rc;

        damon_for_each_target(t, ctx) {
                id = t->id;
                if (targetid_is_pid(ctx))
                        /* Show pid numbers to debugfs users */
                        id = (unsigned long)pid_vnr((struct pid *)id);

                rc = scnprintf(&buf[written], len - written, "%lu ", id);
                if (!rc)
                        return -ENOMEM;
                written += rc;
        }
        if (written)
                written -= 1;
        written += scnprintf(&buf[written], len - written, "\n");
        return written;
}

static ssize_t dbgfs_target_ids_read(struct file *file,
                char __user *buf, size_t count, loff_t *ppos)
{
        struct damon_ctx *ctx = file->private_data;
        ssize_t len;
        char ids_buf[320];

        mutex_lock(&ctx->kdamond_lock);
        len = sprint_target_ids(ctx, ids_buf, 320);
        mutex_unlock(&ctx->kdamond_lock);
        if (len < 0)
                return len;

        return simple_read_from_buffer(buf, count, ppos, ids_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 unsigned long *str_to_target_ids(const char *str, ssize_t len,
                                        ssize_t *nr_ids)
{
        unsigned long *ids;
        const int max_nr_ids = 32;
        unsigned long id;
        int pos = 0, parsed, ret;

        *nr_ids = 0;
        ids = kmalloc_array(max_nr_ids, sizeof(id), GFP_KERNEL);
        if (!ids)
                return NULL;
        while (*nr_ids < max_nr_ids && pos < len) {
                ret = sscanf(&str[pos], "%lu%n", &id, &parsed);
                pos += parsed;
                if (ret != 1)
                        break;
                ids[*nr_ids] = id;
                *nr_ids += 1;
        }

        return ids;
}

static void dbgfs_put_pids(unsigned long *ids, int nr_ids)
{
        int i;

        for (i = 0; i < nr_ids; i++)
                put_pid((struct pid *)ids[i]);
}

static ssize_t dbgfs_target_ids_write(struct file *file,
                const char __user *buf, size_t count, loff_t *ppos)
{
        struct damon_ctx *ctx = file->private_data;
        char *kbuf, *nrs;
        unsigned long *targets;
        ssize_t nr_targets;
        ssize_t ret = count;
        int i;
        int err;

        kbuf = user_input_str(buf, count, ppos);
        if (IS_ERR(kbuf))
                return PTR_ERR(kbuf);

        nrs = kbuf;

        targets = str_to_target_ids(nrs, ret, &nr_targets);
        if (!targets) {
                ret = -ENOMEM;
                goto out;
        }

        if (targetid_is_pid(ctx)) {
                for (i = 0; i < nr_targets; i++) {
                        targets[i] = (unsigned long)find_get_pid(
                                        (int)targets[i]);
                        if (!targets[i]) {
                                dbgfs_put_pids(targets, i);
                                ret = -EINVAL;
                                goto free_targets_out;
                        }
                }
        }

        mutex_lock(&ctx->kdamond_lock);
        if (ctx->kdamond) {
                if (targetid_is_pid(ctx))
                        dbgfs_put_pids(targets, nr_targets);
                ret = -EBUSY;
                goto unlock_out;
        }

        err = damon_set_targets(ctx, targets, nr_targets);
        if (err) {
                if (targetid_is_pid(ctx))
                        dbgfs_put_pids(targets, nr_targets);
                ret = err;
        }

unlock_out:
        mutex_unlock(&ctx->kdamond_lock);
free_targets_out:
        kfree(targets);
out:
        kfree(kbuf);
        return ret;
}

static ssize_t dbgfs_kdamond_pid_read(struct file *file,
                char __user *buf, size_t count, loff_t *ppos)
{
        struct damon_ctx *ctx = file->private_data;
        char *kbuf;
        ssize_t len;

        kbuf = kmalloc(count, GFP_KERNEL);
        if (!kbuf)
                return -ENOMEM;

        mutex_lock(&ctx->kdamond_lock);
        if (ctx->kdamond)
                len = scnprintf(kbuf, count, "%d\n", ctx->kdamond->pid);
        else
                len = scnprintf(kbuf, count, "none\n");
        mutex_unlock(&ctx->kdamond_lock);
        if (!len)
                goto out;
        len = simple_read_from_buffer(buf, count, ppos, kbuf, len);

out:
        kfree(kbuf);
        return len;
}

static int damon_dbgfs_open(struct inode *inode, struct file *file)
{
        file->private_data = inode->i_private;

        return nonseekable_open(inode, file);
}

static const struct file_operations attrs_fops = {
        .open = damon_dbgfs_open,
        .read = dbgfs_attrs_read,
        .write = dbgfs_attrs_write,
};

static const struct file_operations target_ids_fops = {
        .open = damon_dbgfs_open,
        .read = dbgfs_target_ids_read,
        .write = dbgfs_target_ids_write,
};

static const struct file_operations kdamond_pid_fops = {
        .open = damon_dbgfs_open,
        .read = dbgfs_kdamond_pid_read,
};

static void dbgfs_fill_ctx_dir(struct dentry *dir, struct damon_ctx *ctx)
{
        const char * const file_names[] = {"attrs", "target_ids",
                "kdamond_pid"};
        const struct file_operations *fops[] = {&attrs_fops, &target_ids_fops,
                &kdamond_pid_fops};
        int i;

        for (i = 0; i < ARRAY_SIZE(file_names); i++)
                debugfs_create_file(file_names[i], 0600, dir, ctx, fops[i]);
}

static int dbgfs_before_terminate(struct damon_ctx *ctx)
{
        struct damon_target *t, *next;

        if (!targetid_is_pid(ctx))
                return 0;

        damon_for_each_target_safe(t, next, ctx) {
                put_pid((struct pid *)t->id);
                damon_destroy_target(t);
        }
        return 0;
}

static struct damon_ctx *dbgfs_new_ctx(void)
{
        struct damon_ctx *ctx;

        ctx = damon_new_ctx();
        if (!ctx)
                return NULL;

        damon_va_set_primitives(ctx);
        ctx->callback.before_terminate = dbgfs_before_terminate;
        return ctx;
}

static void dbgfs_destroy_ctx(struct damon_ctx *ctx)
{
        damon_destroy_ctx(ctx);
}

/*
 * Make a context of @name and create a debugfs directory for it.
 *
 * This function should be called while holding damon_dbgfs_lock.
 *
 * Returns 0 on success, negative error code otherwise.
 */
static int dbgfs_mk_context(char *name)
{
        struct dentry *root, **new_dirs, *new_dir;
        struct damon_ctx **new_ctxs, *new_ctx;

        if (damon_nr_running_ctxs())
                return -EBUSY;

        new_ctxs = krealloc(dbgfs_ctxs, sizeof(*dbgfs_ctxs) *
                        (dbgfs_nr_ctxs + 1), GFP_KERNEL);
        if (!new_ctxs)
                return -ENOMEM;
        dbgfs_ctxs = new_ctxs;

        new_dirs = krealloc(dbgfs_dirs, sizeof(*dbgfs_dirs) *
                        (dbgfs_nr_ctxs + 1), GFP_KERNEL);
        if (!new_dirs)
                return -ENOMEM;
        dbgfs_dirs = new_dirs;

        root = dbgfs_dirs[0];
        if (!root)
                return -ENOENT;

        new_dir = debugfs_create_dir(name, root);
        dbgfs_dirs[dbgfs_nr_ctxs] = new_dir;

        new_ctx = dbgfs_new_ctx();
        if (!new_ctx) {
                debugfs_remove(new_dir);
                dbgfs_dirs[dbgfs_nr_ctxs] = NULL;
                return -ENOMEM;
        }

        dbgfs_ctxs[dbgfs_nr_ctxs] = new_ctx;
        dbgfs_fill_ctx_dir(dbgfs_dirs[dbgfs_nr_ctxs],
                        dbgfs_ctxs[dbgfs_nr_ctxs]);
        dbgfs_nr_ctxs++;

        return 0;
}

static ssize_t dbgfs_mk_context_write(struct file *file,
                const char __user *buf, size_t count, loff_t *ppos)
{
        char *kbuf;
        char *ctx_name;
        ssize_t ret = count;
        int err;

        kbuf = user_input_str(buf, count, ppos);
        if (IS_ERR(kbuf))
                return PTR_ERR(kbuf);
        ctx_name = kmalloc(count + 1, GFP_KERNEL);
        if (!ctx_name) {
                kfree(kbuf);
                return -ENOMEM;
        }

        /* Trim white space */
        if (sscanf(kbuf, "%s", ctx_name) != 1) {
                ret = -EINVAL;
                goto out;
        }

        mutex_lock(&damon_dbgfs_lock);
        err = dbgfs_mk_context(ctx_name);
        if (err)
                ret = err;
        mutex_unlock(&damon_dbgfs_lock);

out:
        kfree(kbuf);
        kfree(ctx_name);
        return ret;
}

/*
 * Remove a context of @name and its debugfs directory.
 *
 * This function should be called while holding damon_dbgfs_lock.
 *
 * Return 0 on success, negative error code otherwise.
 */
static int dbgfs_rm_context(char *name)
{
        struct dentry *root, *dir, **new_dirs;
        struct damon_ctx **new_ctxs;
        int i, j;

        if (damon_nr_running_ctxs())
                return -EBUSY;

        root = dbgfs_dirs[0];
        if (!root)
                return -ENOENT;

        dir = debugfs_lookup(name, root);
        if (!dir)
                return -ENOENT;

        new_dirs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_dirs),
                        GFP_KERNEL);
        if (!new_dirs)
                return -ENOMEM;

        new_ctxs = kmalloc_array(dbgfs_nr_ctxs - 1, sizeof(*dbgfs_ctxs),
                        GFP_KERNEL);
        if (!new_ctxs) {
                kfree(new_dirs);
                return -ENOMEM;
        }

        for (i = 0, j = 0; i < dbgfs_nr_ctxs; i++) {
                if (dbgfs_dirs[i] == dir) {
                        debugfs_remove(dbgfs_dirs[i]);
                        dbgfs_destroy_ctx(dbgfs_ctxs[i]);
                        continue;
                }
                new_dirs[j] = dbgfs_dirs[i];
                new_ctxs[j++] = dbgfs_ctxs[i];
        }

        kfree(dbgfs_dirs);
        kfree(dbgfs_ctxs);

        dbgfs_dirs = new_dirs;
        dbgfs_ctxs = new_ctxs;
        dbgfs_nr_ctxs--;

        return 0;
}

static ssize_t dbgfs_rm_context_write(struct file *file,
                const char __user *buf, size_t count, loff_t *ppos)
{
        char *kbuf;
        ssize_t ret = count;
        int err;
        char *ctx_name;

        kbuf = user_input_str(buf, count, ppos);
        if (IS_ERR(kbuf))
                return PTR_ERR(kbuf);
        ctx_name = kmalloc(count + 1, GFP_KERNEL);
        if (!ctx_name) {
                kfree(kbuf);
                return -ENOMEM;
        }

        /* Trim white space */
        if (sscanf(kbuf, "%s", ctx_name) != 1) {
                ret = -EINVAL;
                goto out;
        }

        mutex_lock(&damon_dbgfs_lock);
        err = dbgfs_rm_context(ctx_name);
        if (err)
                ret = err;
        mutex_unlock(&damon_dbgfs_lock);

out:
        kfree(kbuf);
        kfree(ctx_name);
        return ret;
}

static ssize_t dbgfs_monitor_on_read(struct file *file,
                char __user *buf, size_t count, loff_t *ppos)
{
        char monitor_on_buf[5];
        bool monitor_on = damon_nr_running_ctxs() != 0;
        int len;

        len = scnprintf(monitor_on_buf, 5, monitor_on ? "on\n" : "off\n");

        return simple_read_from_buffer(buf, count, ppos, monitor_on_buf, len);
}

static ssize_t dbgfs_monitor_on_write(struct file *file,
                const char __user *buf, size_t count, loff_t *ppos)
{
        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) {
                kfree(kbuf);
                return -EINVAL;
        }

        if (!strncmp(kbuf, "on", count))
                err = damon_start(dbgfs_ctxs, dbgfs_nr_ctxs);
        else if (!strncmp(kbuf, "off", count))
                err = damon_stop(dbgfs_ctxs, dbgfs_nr_ctxs);
        else
                err = -EINVAL;

        if (err)
                ret = err;
        kfree(kbuf);
        return ret;
}

static const struct file_operations mk_contexts_fops = {
        .write = dbgfs_mk_context_write,
};

static const struct file_operations rm_contexts_fops = {
        .write = dbgfs_rm_context_write,
};

static const struct file_operations monitor_on_fops = {
        .read = dbgfs_monitor_on_read,
        .write = dbgfs_monitor_on_write,
};

static int __init __damon_dbgfs_init(void)
{
        struct dentry *dbgfs_root;
        const char * const file_names[] = {"mk_contexts", "rm_contexts",
                "monitor_on"};
        const struct file_operations *fops[] = {&mk_contexts_fops,
                &rm_contexts_fops, &monitor_on_fops};
        int i;

        dbgfs_root = debugfs_create_dir("damon", NULL);

        for (i = 0; i < ARRAY_SIZE(file_names); i++)
                debugfs_create_file(file_names[i], 0600, dbgfs_root, NULL,
                                fops[i]);
        dbgfs_fill_ctx_dir(dbgfs_root, dbgfs_ctxs[0]);

        dbgfs_dirs = kmalloc_array(1, sizeof(dbgfs_root), GFP_KERNEL);
        if (!dbgfs_dirs) {
                debugfs_remove(dbgfs_root);
                return -ENOMEM;
        }
        dbgfs_dirs[0] = dbgfs_root;

        return 0;
}

/*
 * Functions for the initialization
 */

static int __init damon_dbgfs_init(void)
{
        int rc;

        dbgfs_ctxs = kmalloc(sizeof(*dbgfs_ctxs), GFP_KERNEL);
        if (!dbgfs_ctxs)
                return -ENOMEM;
        dbgfs_ctxs[0] = dbgfs_new_ctx();
        if (!dbgfs_ctxs[0]) {
                kfree(dbgfs_ctxs);
                return -ENOMEM;
        }
        dbgfs_nr_ctxs = 1;

        rc = __damon_dbgfs_init();
        if (rc) {
                kfree(dbgfs_ctxs[0]);
                kfree(dbgfs_ctxs);
                pr_err("%s: dbgfs init failed\n", __func__);
        }

        return rc;
}

module_init(damon_dbgfs_init);

#include "dbgfs-test.h"