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         mutex_unlock(&event_mutex);
  74
  75         return ret;
  76 }
  77
  78 static int create_dyn_event(int argc, char **argv)
  79 {
  80         struct dyn_event_operations *ops;
  81         int ret = -ENODEV;
  82
  83         if (argv[0][0] == '-' || argv[0][0] == '!')
  84                 return dyn_event_release(argc, argv, NULL);
  85
  86         mutex_lock(&dyn_event_ops_mutex);
  87         list_for_each_entry(ops, &dyn_event_ops_list, list) {
  88                 ret = ops->create(argc, (const char **)argv);
  89                 if (!ret || ret != -ECANCELED)
  90                         break;
  91         }
  92         mutex_unlock(&dyn_event_ops_mutex);
  93         if (ret == -ECANCELED)
  94                 ret = -EINVAL;
  95
  96         return ret;
  97 }
  98
  99 /* Protected by event_mutex */
 100 LIST_HEAD(dyn_event_list);
 101
 102 void *dyn_event_seq_start(struct seq_file *m, loff_t *pos)
 103 {
 104         mutex_lock(&event_mutex);
 105         return seq_list_start(&dyn_event_list, *pos);
 106 }
 107
 108 void *dyn_event_seq_next(struct seq_file *m, void *v, loff_t *pos)
 109 {
 110         return seq_list_next(v, &dyn_event_list, pos);
 111 }
 112
 113 void dyn_event_seq_stop(struct seq_file *m, void *v)
 114 {
 115         mutex_unlock(&event_mutex);
 116 }
 117
 118 static int dyn_event_seq_show(struct seq_file *m, void *v)
 119 {
 120         struct dyn_event *ev = v;
 121
 122         if (ev && ev->ops)
 123                 return ev->ops->show(m, ev);
 124
 125         return 0;
 126 }
 127
 128 static const struct seq_operations dyn_event_seq_op = {
 129         .start  = dyn_event_seq_start,
 130         .next   = dyn_event_seq_next,
 131         .stop   = dyn_event_seq_stop,
 132         .show   = dyn_event_seq_show
 133 };
 134
 135 /*
 136  * dyn_events_release_all - Release all specific events
 137  * @type:       the dyn_event_operations * which filters releasing events
 138  *
 139  * This releases all events which ->ops matches @type. If @type is NULL,
 140  * all events are released.
 141  * Return -EBUSY if any of them are in use, and return other errors when
 142  * it failed to free the given event. Except for -EBUSY, event releasing
 143  * process will be aborted at that point and there may be some other
 144  * releasable events on the list.
 145  */
 146 int dyn_events_release_all(struct dyn_event_operations *type)
 147 {
 148         struct dyn_event *ev, *tmp;
 149         int ret = 0;
 150
 151         mutex_lock(&event_mutex);
 152         for_each_dyn_event(ev) {
 153                 if (type && ev->ops != type)
 154                         continue;
 155                 if (ev->ops->is_busy(ev)) {
 156                         ret = -EBUSY;
 157                         goto out;
 158                 }
 159         }
 160         for_each_dyn_event_safe(ev, tmp) {
 161                 if (type && ev->ops != type)
 162                         continue;
 163                 ret = ev->ops->free(ev);
 164                 if (ret)
 165                         break;
 166         }
 167 out:
 168         mutex_unlock(&event_mutex);
 169
 170         return ret;
 171 }
 172
 173 static int dyn_event_open(struct inode *inode, struct file *file)
 174 {
 175         int ret;
 176
 177         ret = tracing_check_open_get_tr(NULL);
 178         if (ret)
 179                 return ret;
 180
 181         if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
 182                 ret = dyn_events_release_all(NULL);
 183                 if (ret < 0)
 184                         return ret;
 185         }
 186
 187         return seq_open(file, &dyn_event_seq_op);
 188 }
 189
 190 static ssize_t dyn_event_write(struct file *file, const char __user *buffer,
 191                                 size_t count, loff_t *ppos)
 192 {
 193         return trace_parse_run_command(file, buffer, count, ppos,
 194                                        create_dyn_event);
 195 }
 196
 197 static const struct file_operations dynamic_events_ops = {
 198         .owner          = THIS_MODULE,
 199         .open           = dyn_event_open,
 200         .read           = seq_read,
 201         .llseek         = seq_lseek,
 202         .release        = seq_release,
 203         .write          = dyn_event_write,
 204 };
 205
 206 /* Make a tracefs interface for controlling dynamic events */
 207 static __init int init_dynamic_event(void)
 208 {
 209         struct dentry *d_tracer;
 210         struct dentry *entry;
 211
 212         d_tracer = tracing_init_dentry();
 213         if (IS_ERR(d_tracer))
 214                 return 0;
 215
 216         entry = tracefs_create_file("dynamic_events", 0644, d_tracer,
 217                                     NULL, &dynamic_events_ops);
 218
 219         /* Event list interface */
 220         if (!entry)
 221                 pr_warn("Could not create tracefs 'dynamic_events' entry\n");
 222
 223         return 0;
 224 }
 225 fs_initcall(init_dynamic_event);
 226
 227 /**
 228  * dynevent_arg_add - Add an arg to a dynevent_cmd
 229  * @cmd: A pointer to the dynevent_cmd struct representing the new event cmd
 230  * @arg: The argument to append to the current cmd
 231  * @check_arg: An (optional) pointer to a function checking arg sanity
 232  *
 233  * Append an argument to a dynevent_cmd.  The argument string will be
 234  * appended to the current cmd string, followed by a separator, if
 235  * applicable.  Before the argument is added, the @check_arg function,
 236  * if present, will be used to check the sanity of the current arg
 237  * string.
 238  *
 239  * The cmd string and separator should be set using the
 240  * dynevent_arg_init() before any arguments are added using this
 241  * function.
 242  *
 243  * Return: 0 if successful, error otherwise.
 244  */
 245 int dynevent_arg_add(struct dynevent_cmd *cmd,
 246                      struct dynevent_arg *arg,
 247                      dynevent_check_arg_fn_t check_arg)
 248 {
 249         int ret = 0;
 250         int delta;
 251         char *q;
 252
 253         if (check_arg) {
 254                 ret = check_arg(arg);
 255                 if (ret)
 256                         return ret;
 257         }
 258
 259         q = cmd->buf + (cmd->maxlen - cmd->remaining);
 260
 261         delta = snprintf(q, cmd->remaining, " %s%c", arg->str, arg->separator);
 262         if (delta >= cmd->remaining) {
 263                 pr_err("String is too long: %s\n", arg->str);
 264                 return -E2BIG;
 265         }
 266         cmd->remaining -= delta;
 267
 268         return ret;
 269 }
 270
 271 /**
 272  * dynevent_arg_pair_add - Add an arg pair to a dynevent_cmd
 273  * @cmd: A pointer to the dynevent_cmd struct representing the new event cmd
 274  * @arg_pair: The argument pair to append to the current cmd
 275  * @check_arg: An (optional) pointer to a function checking arg sanity
 276  *
 277  * Append an argument pair to a dynevent_cmd.  An argument pair
 278  * consists of a left-hand-side argument and a right-hand-side
 279  * argument separated by an operator, which can be whitespace, all
 280  * followed by a separator, if applicable.  This can be used to add
 281  * arguments of the form 'type variable_name;' or 'x+y'.
 282  *
 283  * The lhs argument string will be appended to the current cmd string,
 284  * followed by an operator, if applicable, followd by the rhs string,
 285  * followed finally by a separator, if applicable.  Before the
 286  * argument is added, the @check_arg function, if present, will be
 287  * used to check the sanity of the current arg strings.
 288  *
 289  * The cmd strings, operator, and separator should be set using the
 290  * dynevent_arg_pair_init() before any arguments are added using this
 291  * function.
 292  *
 293  * Return: 0 if successful, error otherwise.
 294  */
 295 int dynevent_arg_pair_add(struct dynevent_cmd *cmd,
 296                           struct dynevent_arg_pair *arg_pair,
 297                           dynevent_check_arg_fn_t check_arg)
 298 {
 299         int ret = 0;
 300         int delta;
 301         char *q;
 302
 303         if (check_arg) {
 304                 ret = check_arg(arg_pair);
 305                 if (ret)
 306                         return ret;
 307         }
 308
 309         q = cmd->buf + (cmd->maxlen - cmd->remaining);
 310
 311         delta = snprintf(q, cmd->remaining, " %s%c", arg_pair->lhs,
 312                          arg_pair->operator);
 313         if (delta >= cmd->remaining) {
 314                 pr_err("field string is too long: %s\n", arg_pair->lhs);
 315                 return -E2BIG;
 316         }
 317         cmd->remaining -= delta; q += delta;
 318
 319         delta = snprintf(q, cmd->remaining, "%s%c", arg_pair->rhs,
 320                          arg_pair->separator);
 321         if (delta >= cmd->remaining) {
 322                 pr_err("field string is too long: %s\n", arg_pair->rhs);
 323                 return -E2BIG;
 324         }
 325         cmd->remaining -= delta; q += delta;
 326
 327         return ret;
 328 }
 329
 330 /**
 331  * dynevent_str_add - Add a string to a dynevent_cmd
 332  * @cmd: A pointer to the dynevent_cmd struct representing the new event cmd
 333  * @str: The string to append to the current cmd
 334  *
 335  * Append a string to a dynevent_cmd.  The string will be appended to
 336  * the current cmd string as-is, with nothing prepended or appended.
 337  *
 338  * Return: 0 if successful, error otherwise.
 339  */
 340 int dynevent_str_add(struct dynevent_cmd *cmd, const char *str)
 341 {
 342         int ret = 0;
 343         int delta;
 344         char *q;
 345
 346         q = cmd->buf + (cmd->maxlen - cmd->remaining);
 347
 348         delta = snprintf(q, cmd->remaining, "%s", str);
 349         if (delta >= cmd->remaining) {
 350                 pr_err("String is too long: %s\n", str);
 351                 return -E2BIG;
 352         }
 353         cmd->remaining -= delta;
 354
 355         return ret;
 356 }
 357
 358 /**
 359  * dynevent_cmd_init - Initialize a dynevent_cmd object
 360  * @cmd: A pointer to the dynevent_cmd struct representing the cmd
 361  * @buf: A pointer to the buffer to generate the command into
 362  * @maxlen: The length of the buffer the command will be generated into
 363  * @type: The type of the cmd, checked against further operations
 364  * @run_command: The type-specific function that will actually run the command
 365  *
 366  * Initialize a dynevent_cmd.  A dynevent_cmd is used to build up and
 367  * run dynamic event creation commands, such as commands for creating
 368  * synthetic and kprobe events.  Before calling any of the functions
 369  * used to build the command, a dynevent_cmd object should be
 370  * instantiated and initialized using this function.
 371  *
 372  * The initialization sets things up by saving a pointer to the
 373  * user-supplied buffer and its length via the @buf and @maxlen
 374  * params, and by saving the cmd-specific @type and @run_command
 375  * params which are used to check subsequent dynevent_cmd operations
 376  * and actually run the command when complete.
 377  */
 378 void dynevent_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen,
 379                        enum dynevent_type type,
 380                        dynevent_create_fn_t run_command)
 381 {
 382         memset(cmd, '\0', sizeof(*cmd));
 383
 384         cmd->buf = buf;
 385         cmd->maxlen = maxlen;
 386         cmd->remaining = cmd->maxlen;
 387         cmd->type = type;
 388         cmd->run_command = run_command;
 389 }
 390
 391 /**
 392  * dynevent_arg_init - Initialize a dynevent_arg object
 393  * @arg: A pointer to the dynevent_arg struct representing the arg
 394  * @separator: An (optional) separator, appended after adding the arg
 395  *
 396  * Initialize a dynevent_arg object.  A dynevent_arg represents an
 397  * object used to append single arguments to the current command
 398  * string.  After the arg string is successfully appended to the
 399  * command string, the optional @separator is appended.  If no
 400  * separator was specified when initializing the arg, a space will be
 401  * appended.
 402  */
 403 void dynevent_arg_init(struct dynevent_arg *arg,
 404                        char separator)
 405 {
 406         memset(arg, '\0', sizeof(*arg));
 407
 408         if (!separator)
 409                 separator = ' ';
 410         arg->separator = separator;
 411 }
 412
 413 /**
 414  * dynevent_arg_pair_init - Initialize a dynevent_arg_pair object
 415  * @arg_pair: A pointer to the dynevent_arg_pair struct representing the arg
 416  * @operator: An (optional) operator, appended after adding the first arg
 417  * @separator: An (optional) separator, appended after adding the second arg
 418  *
 419  * Initialize a dynevent_arg_pair object.  A dynevent_arg_pair
 420  * represents an object used to append argument pairs such as 'type
 421  * variable_name;' or 'x+y' to the current command string.  An
 422  * argument pair consists of a left-hand-side argument and a
 423  * right-hand-side argument separated by an operator, which can be
 424  * whitespace, all followed by a separator, if applicable.  After the
 425  * first arg string is successfully appended to the command string,
 426  * the optional @operator is appended, followed by the second arg and
 427  * and optional @separator.  If no separator was specified when
 428  * initializing the arg, a space will be appended.
 429  */
 430 void dynevent_arg_pair_init(struct dynevent_arg_pair *arg_pair,
 431                             char operator, char separator)
 432 {
 433         memset(arg_pair, '\0', sizeof(*arg_pair));
 434
 435         if (!operator)
 436                 operator = ' ';
 437         arg_pair->operator = operator;
 438
 439         if (!separator)
 440                 separator = ' ';
 441         arg_pair->separator = separator;
 442 }
 443
 444 /**
 445  * dynevent_create - Create the dynamic event contained in dynevent_cmd
 446  * @cmd: The dynevent_cmd object containing the dynamic event creation command
 447  *
 448  * Once a dynevent_cmd object has been successfully built up via the
 449  * dynevent_cmd_init(), dynevent_arg_add() and dynevent_arg_pair_add()
 450  * functions, this function runs the final command to actually create
 451  * the event.
 452  *
 453  * Return: 0 if the event was successfully created, error otherwise.
 454  */
 455 int dynevent_create(struct dynevent_cmd *cmd)
 456 {
 457         return cmd->run_command(cmd);
 458 }
 459 EXPORT_SYMBOL_GPL(dynevent_create);