OSCL-LXR linux-6.0.1/​kernel/​trace/​rv/​rv_reactors.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // 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,
     .llseek = no_llseek,
     .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;
 }

This page was automatically generated by the 2.1.0 LXR engine. The LXR team