kernel/trace/trace_dynevent.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Generic dynamic event control interface
   4  *
   5  * Copyright (C) 2018 Masami Hiramatsu <mhiramat@kernel.org>
   6  */
   7
   8 #include <linux/debugfs.h>
   9 #include <linux/kernel.h>
  10 #include <linux/list.h>
  11 #include <linux/mm.h>
  12 #include <linux/mutex.h>
  13 #include <linux/tracefs.h>
  14
  15 #include "trace.h"
  16 #include "trace_dynevent.h"
  17
  18 static DEFINE_MUTEX(dyn_event_ops_mutex);
  19 static LIST_HEAD(dyn_event_ops_list);
  20
  21 int dyn_event_register(struct dyn_event_operations *ops)
  22 {
  23         if (!ops || !ops->create || !ops->show || !ops->is_busy ||
  24             !ops->free || !ops->match)
  25                 return -EINVAL;
  26
  27         INIT_LIST_HEAD(&ops->list);
  28         mutex_lock(&dyn_event_ops_mutex);
  29         list_add_tail(&ops->list, &dyn_event_ops_list);
  30         mutex_unlock(&dyn_event_ops_mutex);
  31         return 0;
  32 }
  33
  34 int dyn_event_release(int argc, char **argv, struct dyn_event_operations *type)
  35 {
  36         struct dyn_event *pos, *n;
  37         char *system = NULL, *event, *p;
  38         int ret = -ENOENT;
  39
  40         if (argv[0][0] == '-') {
  41                 if (argv[0][1] != ':')
  42                         return -EINVAL;
  43                 event = &argv[0][2];
  44         } else {
  45                 event = strchr(argv[0], ':');
  46                 if (!event)
  47                         return -EINVAL;
  48                 event++;
  49         }
  50         argc--; argv++;
  51
  52         p = strchr(event, '/');
  53         if (p) {
  54                 system = event;
  55                 event = p + 1;
  56                 *p = '\0';
  57         }
  58         if (event[0] == '\0')
  59                 return -EINVAL;
  60
  61         mutex_lock(&event_mutex);
  62         for_each_dyn_event_safe(pos, n) {
  63                 if (type && type != pos->ops)
  64                         continue;
  65                 if (!pos->ops->match(system, event,
  66                                 argc, (const char **)argv, pos))
  67                         continue;
  68
  69                 ret = pos->ops->free(pos);
  70                 if (ret)
  71                         break;
  72         }
  73         tracing_reset_all_online_cpus();
  74         mutex_unlock(&event_mutex);
  75
  76         return ret;
  77 }
  78
  79 static int create_dyn_event(int argc, char **argv)
  80 {
  81         struct dyn_event_operations *ops;
  82         int ret = -ENODEV;
  83
  84         if (argv[0][0] == '-' || argv[0][0] == '!')
  85                 return dyn_event_release(argc, argv, NULL);
  86
  87         mutex_lock(&dyn_event_ops_mutex);
  88         list_for_each_entry(ops, &dyn_event_ops_list, list) {
  89                 ret = ops->create(argc, (const char **)argv);
  90                 if (!ret || ret != -ECANCELED)
  91                         break;
  92         }
  93         mutex_unlock(&dyn_event_ops_mutex);
  94         if (ret == -ECANCELED)
  95                 ret = -EINVAL;
  96
  97         return ret;
  98 }
  99
 100 /* Protected by event_mutex */
 101 LIST_HEAD(dyn_event_list);
 102
 103 void *dyn_event_seq_start(struct seq_file *m, loff_t *pos)
 104 {
 105         mutex_lock(&event_mutex);
 106         return seq_list_start(&dyn_event_list, *pos);
 107 }
 108
 109 void *dyn_event_seq_next(struct seq_file *m, void *v, loff_t *pos)
 110 {
 111         return seq_list_next(v, &dyn_event_list, pos);
 112 }
 113
 114 void dyn_event_seq_stop(struct seq_file *m, void *v)
 115 {
 116         mutex_unlock(&event_mutex);
 117 }
 118
 119 static int dyn_event_seq_show(struct seq_file *m, void *v)
 120 {
 121         struct dyn_event *ev = v;
 122
 123         if (ev && ev->ops)
 124                 return ev->ops->show(m, ev);
 125
 126         return 0;
 127 }
 128
 129 static const struct seq_operations dyn_event_seq_op = {
 130         .start  = dyn_event_seq_start,
 131         .next   = dyn_event_seq_next,
 132         .stop   = dyn_event_seq_stop,
 133         .show   = dyn_event_seq_show
 134 };
 135
 136 /*
 137  * dyn_events_release_all - Release all specific events
 138  * @type:       the dyn_event_operations * which filters releasing events
 139  *
 140  * This releases all events which ->ops matches @type. If @type is NULL,
 141  * all events are released.
 142  * Return -EBUSY if any of them are in use, and return other errors when
 143  * it failed to free the given event. Except for -EBUSY, event releasing
 144  * process will be aborted at that point and there may be some other
 145  * releasable events on the list.
 146  */
 147 int dyn_events_release_all(struct dyn_event_operations *type)
 148 {
 149         struct dyn_event *ev, *tmp;
 150         int ret = 0;
 151
 152         mutex_lock(&event_mutex);
 153         for_each_dyn_event(ev) {
 154                 if (type && ev->ops != type)
 155                         continue;
 156                 if (ev->ops->is_busy(ev)) {
 157                         ret = -EBUSY;
 158                         goto out;
 159                 }
 160         }
 161         for_each_dyn_event_safe(ev, tmp) {
 162                 if (type && ev->ops != type)
 163                         continue;
 164                 ret = ev->ops->free(ev);
 165                 if (ret)
 166                         break;
 167         }
 168 out:
 169         tracing_reset_all_online_cpus();
 170         mutex_unlock(&event_mutex);
 171
 172         return ret;
 173 }
 174
 175 static int dyn_event_open(struct inode *inode, struct file *file)
 176 {
 177         int ret;
 178
 179         ret = tracing_check_open_get_tr(NULL);
 180         if (ret)
 181                 return ret;
 182
 183         if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
 184                 ret = dyn_events_release_all(NULL);
 185                 if (ret < 0)
 186                         return ret;
 187         }
 188
 189         return seq_open(file, &dyn_event_seq_op);
 190 }
 191
 192 static ssize_t dyn_event_write(struct file *file, const char __user *buffer,
 193                                 size_t count, loff_t *ppos)
 194 {
 195         return trace_parse_run_command(file, buffer, count, ppos,
 196                                        create_dyn_event);
 197 }
 198
 199 static const struct file_operations dynamic_events_ops = {
 200         .owner          = THIS_MODULE,
 201         .open           = dyn_event_open,
 202         .read           = seq_read,
 203         .llseek         = seq_lseek,
 204         .release        = seq_release,
 205         .write          = dyn_event_write,
 206 };
 207
 208 /* Make a tracefs interface for controlling dynamic events */
 209 static __init int init_dynamic_event(void)
 210 {
 211         struct dentry *d_tracer;
 212         struct dentry *entry;
 213
 214         d_tracer = tracing_init_dentry();
 215         if (IS_ERR(d_tracer))
 216                 return 0;
 217
 218         entry = tracefs_create_file("dynamic_events", 0644, d_tracer,
 219                                     NULL, &dynamic_events_ops);
 220
 221         /* Event list interface */
 222         if (!entry)
 223                 pr_warn("Could not create tracefs 'dynamic_events' entry\n");
 224
 225         return 0;
 226 }
 227 fs_initcall(init_dynamic_event);