printf: Remove unused 'bprintf'

[drm/drm-misc.git] / kernel / trace / rv / rv_reactors.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2019-2022 Red Hat, Inc. Daniel Bristot de Oliveira <bristot@kernel.org>
 *
 * Runtime reactor interface.
 *
 * A runtime monitor can cause a reaction to the detection of an
 * exception on the model's execution. By default, the monitors have
 * tracing reactions, printing the monitor output via tracepoints.
 * But other reactions can be added (on-demand) via this interface.
 *
 * == Registering reactors ==
 *
 * The struct rv_reactor defines a callback function to be executed
 * in case of a model exception happens. The callback function
 * receives a message to be (optionally) printed before executing
 * the reaction.
 *
 * A RV reactor is registered via:
 *   int rv_register_reactor(struct rv_reactor *reactor)
 * And unregistered via:
 *   int rv_unregister_reactor(struct rv_reactor *reactor)
 *
 * These functions are exported to modules, enabling reactors to be
 * dynamically loaded.
 *
 * == User interface ==
 *
 * The user interface resembles the kernel tracing interface and
 * presents these files:
 *
 *  "available_reactors"
 *    - List the available reactors, one per line.
 *
 *    For example:
 *      # cat available_reactors
 *      nop
 *      panic
 *      printk
 *
 *  "reacting_on"
 *    - It is an on/off general switch for reactors, disabling
 *    all reactions.
 *
 *  "monitors/MONITOR/reactors"
 *    - List available reactors, with the select reaction for the given
 *    MONITOR inside []. The default one is the nop (no operation)
 *    reactor.
 *    - Writing the name of an reactor enables it to the given
 *    MONITOR.
 *
 *    For example:
 *      # cat monitors/wip/reactors
 *      [nop]
 *      panic
 *      printk
 *      # echo panic > monitors/wip/reactors
 *      # cat monitors/wip/reactors
 *      nop
 *      [panic]
 *      printk
 */

#include <linux/slab.h>

#include "rv.h"

/*
 * Interface for the reactor register.
 */
static LIST_HEAD(rv_reactors_list);

static struct rv_reactor_def *get_reactor_rdef_by_name(char *name)
{
        struct rv_reactor_def *r;

        list_for_each_entry(r, &rv_reactors_list, list) {
                if (strcmp(name, r->reactor->name) == 0)
                        return r;
        }
        return NULL;
}

/*
 * Available reactors seq functions.
 */
static int reactors_show(struct seq_file *m, void *p)
{
        struct rv_reactor_def *rea_def = p;

        seq_printf(m, "%s\n", rea_def->reactor->name);
        return 0;
}

static void reactors_stop(struct seq_file *m, void *p)
{
        mutex_unlock(&rv_interface_lock);
}

static void *reactors_start(struct seq_file *m, loff_t *pos)
{
        mutex_lock(&rv_interface_lock);
        return seq_list_start(&rv_reactors_list, *pos);
}

static void *reactors_next(struct seq_file *m, void *p, loff_t *pos)
{
        return seq_list_next(p, &rv_reactors_list, pos);
}

/*
 * available_reactors seq definition.
 */
static const struct seq_operations available_reactors_seq_ops = {
        .start  = reactors_start,
        .next   = reactors_next,
        .stop   = reactors_stop,
        .show   = reactors_show
};

/*
 * available_reactors interface.
 */
static int available_reactors_open(struct inode *inode, struct file *file)
{
        return seq_open(file, &available_reactors_seq_ops);
};

static const struct file_operations available_reactors_ops = {
        .open    = available_reactors_open,
        .read    = seq_read,
        .llseek  = seq_lseek,
        .release = seq_release
};

/*
 * Monitor's reactor file.
 */
static int monitor_reactor_show(struct seq_file *m, void *p)
{
        struct rv_monitor_def *mdef = m->private;
        struct rv_reactor_def *rdef = p;

        if (mdef->rdef == rdef)
                seq_printf(m, "[%s]\n", rdef->reactor->name);
        else
                seq_printf(m, "%s\n", rdef->reactor->name);
        return 0;
}

/*
 * available_reactors seq definition.
 */
static const struct seq_operations monitor_reactors_seq_ops = {
        .start  = reactors_start,
        .next   = reactors_next,
        .stop   = reactors_stop,
        .show   = monitor_reactor_show
};

static void monitor_swap_reactors(struct rv_monitor_def *mdef, struct rv_reactor_def *rdef,
                                    bool reacting)
{
        bool monitor_enabled;

        /* nothing to do */
        if (mdef->rdef == rdef)
                return;

        monitor_enabled = mdef->monitor->enabled;
        if (monitor_enabled)
                rv_disable_monitor(mdef);

        /* swap reactor's usage */
        mdef->rdef->counter--;
        rdef->counter++;

        mdef->rdef = rdef;
        mdef->reacting = reacting;
        mdef->monitor->react = rdef->reactor->react;

        if (monitor_enabled)
                rv_enable_monitor(mdef);
}

static ssize_t
monitor_reactors_write(struct file *file, const char __user *user_buf,
                      size_t count, loff_t *ppos)
{
        char buff[MAX_RV_REACTOR_NAME_SIZE + 2];
        struct rv_monitor_def *mdef;
        struct rv_reactor_def *rdef;
        struct seq_file *seq_f;
        int retval = -EINVAL;
        bool enable;
        char *ptr;
        int len;

        if (count < 1 || count > MAX_RV_REACTOR_NAME_SIZE + 1)
                return -EINVAL;

        memset(buff, 0, sizeof(buff));

        retval = simple_write_to_buffer(buff, sizeof(buff) - 1, ppos, user_buf, count);
        if (retval < 0)
                return -EFAULT;

        ptr = strim(buff);

        len = strlen(ptr);
        if (!len)
                return count;

        /*
         * See monitor_reactors_open()
         */
        seq_f = file->private_data;
        mdef = seq_f->private;

        mutex_lock(&rv_interface_lock);

        retval = -EINVAL;

        list_for_each_entry(rdef, &rv_reactors_list, list) {
                if (strcmp(ptr, rdef->reactor->name) != 0)
                        continue;

                if (rdef == get_reactor_rdef_by_name("nop"))
                        enable = false;
                else
                        enable = true;

                monitor_swap_reactors(mdef, rdef, enable);

                retval = count;
                break;
        }

        mutex_unlock(&rv_interface_lock);

        return retval;
}

/*
 * available_reactors interface.
 */
static int monitor_reactors_open(struct inode *inode, struct file *file)
{
        struct rv_monitor_def *mdef = inode->i_private;
        struct seq_file *seq_f;
        int ret;

        ret = seq_open(file, &monitor_reactors_seq_ops);
        if (ret < 0)
                return ret;

        /*
         * seq_open stores the seq_file on the file->private data.
         */
        seq_f = file->private_data;

        /*
         * Copy the create file "private" data to the seq_file private data.
         */
        seq_f->private = mdef;

        return 0;
};

static const struct file_operations monitor_reactors_ops = {
        .open    = monitor_reactors_open,
        .read    = seq_read,
        .llseek  = seq_lseek,
        .release = seq_release,
        .write = monitor_reactors_write
};

static int __rv_register_reactor(struct rv_reactor *reactor)
{
        struct rv_reactor_def *r;

        list_for_each_entry(r, &rv_reactors_list, list) {
                if (strcmp(reactor->name, r->reactor->name) == 0) {
                        pr_info("Reactor %s is already registered\n", reactor->name);
                        return -EINVAL;
                }
        }

        r = kzalloc(sizeof(struct rv_reactor_def), GFP_KERNEL);
        if (!r)
                return -ENOMEM;

        r->reactor = reactor;
        r->counter = 0;

        list_add_tail(&r->list, &rv_reactors_list);

        return 0;
}

/**
 * rv_register_reactor - register a rv reactor.
 * @reactor:    The rv_reactor to be registered.
 *
 * Returns 0 if successful, error otherwise.
 */
int rv_register_reactor(struct rv_reactor *reactor)
{
        int retval = 0;

        if (strlen(reactor->name) >= MAX_RV_REACTOR_NAME_SIZE) {
                pr_info("Reactor %s has a name longer than %d\n",
                        reactor->name, MAX_RV_MONITOR_NAME_SIZE);
                return -EINVAL;
        }

        mutex_lock(&rv_interface_lock);
        retval = __rv_register_reactor(reactor);
        mutex_unlock(&rv_interface_lock);
        return retval;
}

/**
 * rv_unregister_reactor - unregister a rv reactor.
 * @reactor:    The rv_reactor to be unregistered.
 *
 * Returns 0 if successful, error otherwise.
 */
int rv_unregister_reactor(struct rv_reactor *reactor)
{
        struct rv_reactor_def *ptr, *next;
        int ret = 0;

        mutex_lock(&rv_interface_lock);

        list_for_each_entry_safe(ptr, next, &rv_reactors_list, list) {
                if (strcmp(reactor->name, ptr->reactor->name) == 0) {

                        if (!ptr->counter) {
                                list_del(&ptr->list);
                        } else {
                                printk(KERN_WARNING
                                       "rv: the rv_reactor %s is in use by %d monitor(s)\n",
                                       ptr->reactor->name, ptr->counter);
                                printk(KERN_WARNING "rv: the rv_reactor %s cannot be removed\n",
                                       ptr->reactor->name);
                                ret = -EBUSY;
                                break;
                        }
                }
        }

        mutex_unlock(&rv_interface_lock);
        return ret;
}

/*
 * reacting_on interface.
 */
static bool __read_mostly reacting_on;

/**
 * rv_reacting_on - checks if reacting is on
 *
 * Returns 1 if on, 0 otherwise.
 */
bool rv_reacting_on(void)
{
        /* Ensures that concurrent monitors read consistent reacting_on */
        smp_rmb();
        return READ_ONCE(reacting_on);
}

static ssize_t reacting_on_read_data(struct file *filp,
                                     char __user *user_buf,
                                     size_t count, loff_t *ppos)
{
        char *buff;

        buff = rv_reacting_on() ? "1\n" : "0\n";

        return simple_read_from_buffer(user_buf, count, ppos, buff, strlen(buff)+1);
}

static void turn_reacting_off(void)
{
        WRITE_ONCE(reacting_on, false);
        /* Ensures that concurrent monitors read consistent reacting_on */
        smp_wmb();
}

static void turn_reacting_on(void)
{
        WRITE_ONCE(reacting_on, true);
        /* Ensures that concurrent monitors read consistent reacting_on */
        smp_wmb();
}

static ssize_t reacting_on_write_data(struct file *filp, const char __user *user_buf,
                                      size_t count, loff_t *ppos)
{
        int retval;
        bool val;

        retval = kstrtobool_from_user(user_buf, count, &val);
        if (retval)
                return retval;

        mutex_lock(&rv_interface_lock);

        if (val)
                turn_reacting_on();
        else
                turn_reacting_off();

        /*
         * Wait for the execution of all events to finish
         * before returning to user-space.
         */
        tracepoint_synchronize_unregister();

        mutex_unlock(&rv_interface_lock);

        return count;
}

static const struct file_operations reacting_on_fops = {
        .open   = simple_open,
        .write  = reacting_on_write_data,
        .read   = reacting_on_read_data,
};

/**
 * reactor_populate_monitor - creates per monitor reactors file
 * @mdef:       monitor's definition.
 *
 * Returns 0 if successful, error otherwise.
 */
int reactor_populate_monitor(struct rv_monitor_def *mdef)
{
        struct dentry *tmp;

        tmp = rv_create_file("reactors", RV_MODE_WRITE, mdef->root_d, mdef, &monitor_reactors_ops);
        if (!tmp)
                return -ENOMEM;

        /*
         * Configure as the rv_nop reactor.
         */
        mdef->rdef = get_reactor_rdef_by_name("nop");
        mdef->rdef->counter++;
        mdef->reacting = false;

        return 0;
}

/**
 * reactor_cleanup_monitor - cleanup a monitor reference
 * @mdef:       monitor's definition.
 */
void reactor_cleanup_monitor(struct rv_monitor_def *mdef)
{
        lockdep_assert_held(&rv_interface_lock);
        mdef->rdef->counter--;
        WARN_ON_ONCE(mdef->rdef->counter < 0);
}

/*
 * Nop reactor register
 */
static void rv_nop_reaction(char *msg)
{
}

static struct rv_reactor rv_nop = {
        .name = "nop",
        .description = "no-operation reactor: do nothing.",
        .react = rv_nop_reaction
};

int init_rv_reactors(struct dentry *root_dir)
{
        struct dentry *available, *reacting;
        int retval;

        available = rv_create_file("available_reactors", RV_MODE_READ, root_dir, NULL,
                                   &available_reactors_ops);
        if (!available)
                goto out_err;

        reacting = rv_create_file("reacting_on", RV_MODE_WRITE, root_dir, NULL, &reacting_on_fops);
        if (!reacting)
                goto rm_available;

        retval = __rv_register_reactor(&rv_nop);
        if (retval)
                goto rm_reacting;

        turn_reacting_on();

        return 0;

rm_reacting:
        rv_remove(reacting);
rm_available:
        rv_remove(available);
out_err:
        return -ENOMEM;
}