kernel/trace/trace_events_trigger.c

   1 /*
   2  * trace_events_trigger - trace event triggers
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17  *
  18  * Copyright (C) 2013 Tom Zanussi <tom.zanussi@linux.intel.com>
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/ctype.h>
  23 #include <linux/mutex.h>
  24 #include <linux/slab.h>
  25
  26 #include "trace.h"
  27
  28 static LIST_HEAD(trigger_commands);
  29 static DEFINE_MUTEX(trigger_cmd_mutex);
  30
  31 static void
  32 trigger_data_free(struct event_trigger_data *data)
  33 {
  34         if (data->cmd_ops->set_filter)
  35                 data->cmd_ops->set_filter(NULL, data, NULL);
  36
  37         synchronize_sched(); /* make sure current triggers exit before free */
  38         kfree(data);
  39 }
  40
  41 /**
  42  * event_triggers_call - Call triggers associated with a trace event
  43  * @file: The ftrace_event_file associated with the event
  44  * @rec: The trace entry for the event, NULL for unconditional invocation
  45  *
  46  * For each trigger associated with an event, invoke the trigger
  47  * function registered with the associated trigger command.  If rec is
  48  * non-NULL, it means that the trigger requires further processing and
  49  * shouldn't be unconditionally invoked.  If rec is non-NULL and the
  50  * trigger has a filter associated with it, rec will checked against
  51  * the filter and if the record matches the trigger will be invoked.
  52  * If the trigger is a 'post_trigger', meaning it shouldn't be invoked
  53  * in any case until the current event is written, the trigger
  54  * function isn't invoked but the bit associated with the deferred
  55  * trigger is set in the return value.
  56  *
  57  * Returns an enum event_trigger_type value containing a set bit for
  58  * any trigger that should be deferred, ETT_NONE if nothing to defer.
  59  *
  60  * Called from tracepoint handlers (with rcu_read_lock_sched() held).
  61  *
  62  * Return: an enum event_trigger_type value containing a set bit for
  63  * any trigger that should be deferred, ETT_NONE if nothing to defer.
  64  */
  65 enum event_trigger_type
  66 event_triggers_call(struct ftrace_event_file *file, void *rec)
  67 {
  68         struct event_trigger_data *data;
  69         enum event_trigger_type tt = ETT_NONE;
  70         struct event_filter *filter;
  71
  72         if (list_empty(&file->triggers))
  73                 return tt;
  74
  75         list_for_each_entry_rcu(data, &file->triggers, list) {
  76                 if (!rec) {
  77                         data->ops->func(data);
  78                         continue;
  79                 }
  80                 filter = rcu_dereference(data->filter);
  81                 if (filter && !filter_match_preds(filter, rec))
  82                         continue;
  83                 if (data->cmd_ops->post_trigger) {
  84                         tt |= data->cmd_ops->trigger_type;
  85                         continue;
  86                 }
  87                 data->ops->func(data);
  88         }
  89         return tt;
  90 }
  91 EXPORT_SYMBOL_GPL(event_triggers_call);
  92
  93 /**
  94  * event_triggers_post_call - Call 'post_triggers' for a trace event
  95  * @file: The ftrace_event_file associated with the event
  96  * @tt: enum event_trigger_type containing a set bit for each trigger to invoke
  97  *
  98  * For each trigger associated with an event, invoke the trigger
  99  * function registered with the associated trigger command, if the
 100  * corresponding bit is set in the tt enum passed into this function.
 101  * See @event_triggers_call for details on how those bits are set.
 102  *
 103  * Called from tracepoint handlers (with rcu_read_lock_sched() held).
 104  */
 105 void
 106 event_triggers_post_call(struct ftrace_event_file *file,
 107                          enum event_trigger_type tt)
 108 {
 109         struct event_trigger_data *data;
 110
 111         list_for_each_entry_rcu(data, &file->triggers, list) {
 112                 if (data->cmd_ops->trigger_type & tt)
 113                         data->ops->func(data);
 114         }
 115 }
 116 EXPORT_SYMBOL_GPL(event_triggers_post_call);
 117
 118 static void *trigger_next(struct seq_file *m, void *t, loff_t *pos)
 119 {
 120         struct ftrace_event_file *event_file = event_file_data(m->private);
 121
 122         return seq_list_next(t, &event_file->triggers, pos);
 123 }
 124
 125 static void *trigger_start(struct seq_file *m, loff_t *pos)
 126 {
 127         struct ftrace_event_file *event_file;
 128
 129         /* ->stop() is called even if ->start() fails */
 130         mutex_lock(&event_mutex);
 131         event_file = event_file_data(m->private);
 132         if (unlikely(!event_file))
 133                 return ERR_PTR(-ENODEV);
 134
 135         return seq_list_start(&event_file->triggers, *pos);
 136 }
 137
 138 static void trigger_stop(struct seq_file *m, void *t)
 139 {
 140         mutex_unlock(&event_mutex);
 141 }
 142
 143 static int trigger_show(struct seq_file *m, void *v)
 144 {
 145         struct event_trigger_data *data;
 146
 147         data = list_entry(v, struct event_trigger_data, list);
 148         data->ops->print(m, data->ops, data);
 149
 150         return 0;
 151 }
 152
 153 static const struct seq_operations event_triggers_seq_ops = {
 154         .start = trigger_start,
 155         .next = trigger_next,
 156         .stop = trigger_stop,
 157         .show = trigger_show,
 158 };
 159
 160 static int event_trigger_regex_open(struct inode *inode, struct file *file)
 161 {
 162         int ret = 0;
 163
 164         mutex_lock(&event_mutex);
 165
 166         if (unlikely(!event_file_data(file))) {
 167                 mutex_unlock(&event_mutex);
 168                 return -ENODEV;
 169         }
 170
 171         if (file->f_mode & FMODE_READ) {
 172                 ret = seq_open(file, &event_triggers_seq_ops);
 173                 if (!ret) {
 174                         struct seq_file *m = file->private_data;
 175                         m->private = file;
 176                 }
 177         }
 178
 179         mutex_unlock(&event_mutex);
 180
 181         return ret;
 182 }
 183
 184 static int trigger_process_regex(struct ftrace_event_file *file, char *buff)
 185 {
 186         char *command, *next = buff;
 187         struct event_command *p;
 188         int ret = -EINVAL;
 189
 190         command = strsep(&next, ": \t");
 191         command = (command[0] != '!') ? command : command + 1;
 192
 193         mutex_lock(&trigger_cmd_mutex);
 194         list_for_each_entry(p, &trigger_commands, list) {
 195                 if (strcmp(p->name, command) == 0) {
 196                         ret = p->func(p, file, buff, command, next);
 197                         goto out_unlock;
 198                 }
 199         }
 200  out_unlock:
 201         mutex_unlock(&trigger_cmd_mutex);
 202
 203         return ret;
 204 }
 205
 206 static ssize_t event_trigger_regex_write(struct file *file,
 207                                          const char __user *ubuf,
 208                                          size_t cnt, loff_t *ppos)
 209 {
 210         struct ftrace_event_file *event_file;
 211         ssize_t ret;
 212         char *buf;
 213
 214         if (!cnt)
 215                 return 0;
 216
 217         if (cnt >= PAGE_SIZE)
 218                 return -EINVAL;
 219
 220         buf = (char *)__get_free_page(GFP_TEMPORARY);
 221         if (!buf)
 222                 return -ENOMEM;
 223
 224         if (copy_from_user(buf, ubuf, cnt)) {
 225                 free_page((unsigned long)buf);
 226                 return -EFAULT;
 227         }
 228         buf[cnt] = '\0';
 229         strim(buf);
 230
 231         mutex_lock(&event_mutex);
 232         event_file = event_file_data(file);
 233         if (unlikely(!event_file)) {
 234                 mutex_unlock(&event_mutex);
 235                 free_page((unsigned long)buf);
 236                 return -ENODEV;
 237         }
 238         ret = trigger_process_regex(event_file, buf);
 239         mutex_unlock(&event_mutex);
 240
 241         free_page((unsigned long)buf);
 242         if (ret < 0)
 243                 goto out;
 244
 245         *ppos += cnt;
 246         ret = cnt;
 247  out:
 248         return ret;
 249 }
 250
 251 static int event_trigger_regex_release(struct inode *inode, struct file *file)
 252 {
 253         mutex_lock(&event_mutex);
 254
 255         if (file->f_mode & FMODE_READ)
 256                 seq_release(inode, file);
 257
 258         mutex_unlock(&event_mutex);
 259
 260         return 0;
 261 }
 262
 263 static ssize_t
 264 event_trigger_write(struct file *filp, const char __user *ubuf,
 265                     size_t cnt, loff_t *ppos)
 266 {
 267         return event_trigger_regex_write(filp, ubuf, cnt, ppos);
 268 }
 269
 270 static int
 271 event_trigger_open(struct inode *inode, struct file *filp)
 272 {
 273         return event_trigger_regex_open(inode, filp);
 274 }
 275
 276 static int
 277 event_trigger_release(struct inode *inode, struct file *file)
 278 {
 279         return event_trigger_regex_release(inode, file);
 280 }
 281
 282 const struct file_operations event_trigger_fops = {
 283         .open = event_trigger_open,
 284         .read = seq_read,
 285         .write = event_trigger_write,
 286         .llseek = tracing_lseek,
 287         .release = event_trigger_release,
 288 };
 289
 290 /*
 291  * Currently we only register event commands from __init, so mark this
 292  * __init too.
 293  */
 294 static __init int register_event_command(struct event_command *cmd)
 295 {
 296         struct event_command *p;
 297         int ret = 0;
 298
 299         mutex_lock(&trigger_cmd_mutex);
 300         list_for_each_entry(p, &trigger_commands, list) {
 301                 if (strcmp(cmd->name, p->name) == 0) {
 302                         ret = -EBUSY;
 303                         goto out_unlock;
 304                 }
 305         }
 306         list_add(&cmd->list, &trigger_commands);
 307  out_unlock:
 308         mutex_unlock(&trigger_cmd_mutex);
 309
 310         return ret;
 311 }
 312
 313 /*
 314  * Currently we only unregister event commands from __init, so mark
 315  * this __init too.
 316  */
 317 static __init int unregister_event_command(struct event_command *cmd)
 318 {
 319         struct event_command *p, *n;
 320         int ret = -ENODEV;
 321
 322         mutex_lock(&trigger_cmd_mutex);
 323         list_for_each_entry_safe(p, n, &trigger_commands, list) {
 324                 if (strcmp(cmd->name, p->name) == 0) {
 325                         ret = 0;
 326                         list_del_init(&p->list);
 327                         goto out_unlock;
 328                 }
 329         }
 330  out_unlock:
 331         mutex_unlock(&trigger_cmd_mutex);
 332
 333         return ret;
 334 }
 335
 336 /**
 337  * event_trigger_print - Generic event_trigger_ops @print implementation
 338  * @name: The name of the event trigger
 339  * @m: The seq_file being printed to
 340  * @data: Trigger-specific data
 341  * @filter_str: filter_str to print, if present
 342  *
 343  * Common implementation for event triggers to print themselves.
 344  *
 345  * Usually wrapped by a function that simply sets the @name of the
 346  * trigger command and then invokes this.
 347  *
 348  * Return: 0 on success, errno otherwise
 349  */
 350 static int
 351 event_trigger_print(const char *name, struct seq_file *m,
 352                     void *data, char *filter_str)
 353 {
 354         long count = (long)data;
 355
 356         seq_printf(m, "%s", name);
 357
 358         if (count == -1)
 359                 seq_puts(m, ":unlimited");
 360         else
 361                 seq_printf(m, ":count=%ld", count);
 362
 363         if (filter_str)
 364                 seq_printf(m, " if %s\n", filter_str);
 365         else
 366                 seq_puts(m, "\n");
 367
 368         return 0;
 369 }
 370
 371 /**
 372  * event_trigger_init - Generic event_trigger_ops @init implementation
 373  * @ops: The trigger ops associated with the trigger
 374  * @data: Trigger-specific data
 375  *
 376  * Common implementation of event trigger initialization.
 377  *
 378  * Usually used directly as the @init method in event trigger
 379  * implementations.
 380  *
 381  * Return: 0 on success, errno otherwise
 382  */
 383 static int
 384 event_trigger_init(struct event_trigger_ops *ops,
 385                    struct event_trigger_data *data)
 386 {
 387         data->ref++;
 388         return 0;
 389 }
 390
 391 /**
 392  * event_trigger_free - Generic event_trigger_ops @free implementation
 393  * @ops: The trigger ops associated with the trigger
 394  * @data: Trigger-specific data
 395  *
 396  * Common implementation of event trigger de-initialization.
 397  *
 398  * Usually used directly as the @free method in event trigger
 399  * implementations.
 400  */
 401 static void
 402 event_trigger_free(struct event_trigger_ops *ops,
 403                    struct event_trigger_data *data)
 404 {
 405         if (WARN_ON_ONCE(data->ref <= 0))
 406                 return;
 407
 408         data->ref--;
 409         if (!data->ref)
 410                 trigger_data_free(data);
 411 }
 412
 413 static int trace_event_trigger_enable_disable(struct ftrace_event_file *file,
 414                                               int trigger_enable)
 415 {
 416         int ret = 0;
 417
 418         if (trigger_enable) {
 419                 if (atomic_inc_return(&file->tm_ref) > 1)
 420                         return ret;
 421                 set_bit(FTRACE_EVENT_FL_TRIGGER_MODE_BIT, &file->flags);
 422                 ret = trace_event_enable_disable(file, 1, 1);
 423         } else {
 424                 if (atomic_dec_return(&file->tm_ref) > 0)
 425                         return ret;
 426                 clear_bit(FTRACE_EVENT_FL_TRIGGER_MODE_BIT, &file->flags);
 427                 ret = trace_event_enable_disable(file, 0, 1);
 428         }
 429
 430         return ret;
 431 }
 432
 433 /**
 434  * clear_event_triggers - Clear all triggers associated with a trace array
 435  * @tr: The trace array to clear
 436  *
 437  * For each trigger, the triggering event has its tm_ref decremented
 438  * via trace_event_trigger_enable_disable(), and any associated event
 439  * (in the case of enable/disable_event triggers) will have its sm_ref
 440  * decremented via free()->trace_event_enable_disable().  That
 441  * combination effectively reverses the soft-mode/trigger state added
 442  * by trigger registration.
 443  *
 444  * Must be called with event_mutex held.
 445  */
 446 void
 447 clear_event_triggers(struct trace_array *tr)
 448 {
 449         struct ftrace_event_file *file;
 450
 451         list_for_each_entry(file, &tr->events, list) {
 452                 struct event_trigger_data *data;
 453                 list_for_each_entry_rcu(data, &file->triggers, list) {
 454                         trace_event_trigger_enable_disable(file, 0);
 455                         if (data->ops->free)
 456                                 data->ops->free(data->ops, data);
 457                 }
 458         }
 459 }
 460
 461 /**
 462  * update_cond_flag - Set or reset the TRIGGER_COND bit
 463  * @file: The ftrace_event_file associated with the event
 464  *
 465  * If an event has triggers and any of those triggers has a filter or
 466  * a post_trigger, trigger invocation needs to be deferred until after
 467  * the current event has logged its data, and the event should have
 468  * its TRIGGER_COND bit set, otherwise the TRIGGER_COND bit should be
 469  * cleared.
 470  */
 471 static void update_cond_flag(struct ftrace_event_file *file)
 472 {
 473         struct event_trigger_data *data;
 474         bool set_cond = false;
 475
 476         list_for_each_entry_rcu(data, &file->triggers, list) {
 477                 if (data->filter || data->cmd_ops->post_trigger) {
 478                         set_cond = true;
 479                         break;
 480                 }
 481         }
 482
 483         if (set_cond)
 484                 set_bit(FTRACE_EVENT_FL_TRIGGER_COND_BIT, &file->flags);
 485         else
 486                 clear_bit(FTRACE_EVENT_FL_TRIGGER_COND_BIT, &file->flags);
 487 }
 488
 489 /**
 490  * register_trigger - Generic event_command @reg implementation
 491  * @glob: The raw string used to register the trigger
 492  * @ops: The trigger ops associated with the trigger
 493  * @data: Trigger-specific data to associate with the trigger
 494  * @file: The ftrace_event_file associated with the event
 495  *
 496  * Common implementation for event trigger registration.
 497  *
 498  * Usually used directly as the @reg method in event command
 499  * implementations.
 500  *
 501  * Return: 0 on success, errno otherwise
 502  */
 503 static int register_trigger(char *glob, struct event_trigger_ops *ops,
 504                             struct event_trigger_data *data,
 505                             struct ftrace_event_file *file)
 506 {
 507         struct event_trigger_data *test;
 508         int ret = 0;
 509
 510         list_for_each_entry_rcu(test, &file->triggers, list) {
 511                 if (test->cmd_ops->trigger_type == data->cmd_ops->trigger_type) {
 512                         ret = -EEXIST;
 513                         goto out;
 514                 }
 515         }
 516
 517         if (data->ops->init) {
 518                 ret = data->ops->init(data->ops, data);
 519                 if (ret < 0)
 520                         goto out;
 521         }
 522
 523         list_add_rcu(&data->list, &file->triggers);
 524         ret++;
 525
 526         if (trace_event_trigger_enable_disable(file, 1) < 0) {
 527                 list_del_rcu(&data->list);
 528                 ret--;
 529         }
 530         update_cond_flag(file);
 531 out:
 532         return ret;
 533 }
 534
 535 /**
 536  * unregister_trigger - Generic event_command @unreg implementation
 537  * @glob: The raw string used to register the trigger
 538  * @ops: The trigger ops associated with the trigger
 539  * @test: Trigger-specific data used to find the trigger to remove
 540  * @file: The ftrace_event_file associated with the event
 541  *
 542  * Common implementation for event trigger unregistration.
 543  *
 544  * Usually used directly as the @unreg method in event command
 545  * implementations.
 546  */
 547 static void unregister_trigger(char *glob, struct event_trigger_ops *ops,
 548                                struct event_trigger_data *test,
 549                                struct ftrace_event_file *file)
 550 {
 551         struct event_trigger_data *data;
 552         bool unregistered = false;
 553
 554         list_for_each_entry_rcu(data, &file->triggers, list) {
 555                 if (data->cmd_ops->trigger_type == test->cmd_ops->trigger_type) {
 556                         unregistered = true;
 557                         list_del_rcu(&data->list);
 558                         update_cond_flag(file);
 559                         trace_event_trigger_enable_disable(file, 0);
 560                         break;
 561                 }
 562         }
 563
 564         if (unregistered && data->ops->free)
 565                 data->ops->free(data->ops, data);
 566 }
 567
 568 /**
 569  * event_trigger_callback - Generic event_command @func implementation
 570  * @cmd_ops: The command ops, used for trigger registration
 571  * @file: The ftrace_event_file associated with the event
 572  * @glob: The raw string used to register the trigger
 573  * @cmd: The cmd portion of the string used to register the trigger
 574  * @param: The params portion of the string used to register the trigger
 575  *
 576  * Common implementation for event command parsing and trigger
 577  * instantiation.
 578  *
 579  * Usually used directly as the @func method in event command
 580  * implementations.
 581  *
 582  * Return: 0 on success, errno otherwise
 583  */
 584 static int
 585 event_trigger_callback(struct event_command *cmd_ops,
 586                        struct ftrace_event_file *file,
 587                        char *glob, char *cmd, char *param)
 588 {
 589         struct event_trigger_data *trigger_data;
 590         struct event_trigger_ops *trigger_ops;
 591         char *trigger = NULL;
 592         char *number;
 593         int ret;
 594
 595         /* separate the trigger from the filter (t:n [if filter]) */
 596         if (param && isdigit(param[0]))
 597                 trigger = strsep(&param, " \t");
 598
 599         trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);
 600
 601         ret = -ENOMEM;
 602         trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
 603         if (!trigger_data)
 604                 goto out;
 605
 606         trigger_data->count = -1;
 607         trigger_data->ops = trigger_ops;
 608         trigger_data->cmd_ops = cmd_ops;
 609         INIT_LIST_HEAD(&trigger_data->list);
 610
 611         if (glob[0] == '!') {
 612                 cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file);
 613                 kfree(trigger_data);
 614                 ret = 0;
 615                 goto out;
 616         }
 617
 618         if (trigger) {
 619                 number = strsep(&trigger, ":");
 620
 621                 ret = -EINVAL;
 622                 if (!strlen(number))
 623                         goto out_free;
 624
 625                 /*
 626                  * We use the callback data field (which is a pointer)
 627                  * as our counter.
 628                  */
 629                 ret = kstrtoul(number, 0, &trigger_data->count);
 630                 if (ret)
 631                         goto out_free;
 632         }
 633
 634         if (!param) /* if param is non-empty, it's supposed to be a filter */
 635                 goto out_reg;
 636
 637         if (!cmd_ops->set_filter)
 638                 goto out_reg;
 639
 640         ret = cmd_ops->set_filter(param, trigger_data, file);
 641         if (ret < 0)
 642                 goto out_free;
 643
 644  out_reg:
 645         ret = cmd_ops->reg(glob, trigger_ops, trigger_data, file);
 646         /*
 647          * The above returns on success the # of functions enabled,
 648          * but if it didn't find any functions it returns zero.
 649          * Consider no functions a failure too.
 650          */
 651         if (!ret) {
 652                 ret = -ENOENT;
 653                 goto out_free;
 654         } else if (ret < 0)
 655                 goto out_free;
 656         ret = 0;
 657  out:
 658         return ret;
 659
 660  out_free:
 661         if (cmd_ops->set_filter)
 662                 cmd_ops->set_filter(NULL, trigger_data, NULL);
 663         kfree(trigger_data);
 664         goto out;
 665 }
 666
 667 /**
 668  * set_trigger_filter - Generic event_command @set_filter implementation
 669  * @filter_str: The filter string for the trigger, NULL to remove filter
 670  * @trigger_data: Trigger-specific data
 671  * @file: The ftrace_event_file associated with the event
 672  *
 673  * Common implementation for event command filter parsing and filter
 674  * instantiation.
 675  *
 676  * Usually used directly as the @set_filter method in event command
 677  * implementations.
 678  *
 679  * Also used to remove a filter (if filter_str = NULL).
 680  *
 681  * Return: 0 on success, errno otherwise
 682  */
 683 static int set_trigger_filter(char *filter_str,
 684                               struct event_trigger_data *trigger_data,
 685                               struct ftrace_event_file *file)
 686 {
 687         struct event_trigger_data *data = trigger_data;
 688         struct event_filter *filter = NULL, *tmp;
 689         int ret = -EINVAL;
 690         char *s;
 691
 692         if (!filter_str) /* clear the current filter */
 693                 goto assign;
 694
 695         s = strsep(&filter_str, " \t");
 696
 697         if (!strlen(s) || strcmp(s, "if") != 0)
 698                 goto out;
 699
 700         if (!filter_str)
 701                 goto out;
 702
 703         /* The filter is for the 'trigger' event, not the triggered event */
 704         ret = create_event_filter(file->event_call, filter_str, false, &filter);
 705         if (ret)
 706                 goto out;
 707  assign:
 708         tmp = rcu_access_pointer(data->filter);
 709
 710         rcu_assign_pointer(data->filter, filter);
 711
 712         if (tmp) {
 713                 /* Make sure the call is done with the filter */
 714                 synchronize_sched();
 715                 free_event_filter(tmp);
 716         }
 717
 718         kfree(data->filter_str);
 719         data->filter_str = NULL;
 720
 721         if (filter_str) {
 722                 data->filter_str = kstrdup(filter_str, GFP_KERNEL);
 723                 if (!data->filter_str) {
 724                         free_event_filter(rcu_access_pointer(data->filter));
 725                         data->filter = NULL;
 726                         ret = -ENOMEM;
 727                 }
 728         }
 729  out:
 730         return ret;
 731 }
 732
 733 static void
 734 traceon_trigger(struct event_trigger_data *data)
 735 {
 736         if (tracing_is_on())
 737                 return;
 738
 739         tracing_on();
 740 }
 741
 742 static void
 743 traceon_count_trigger(struct event_trigger_data *data)
 744 {
 745         if (tracing_is_on())
 746                 return;
 747
 748         if (!data->count)
 749                 return;
 750
 751         if (data->count != -1)
 752                 (data->count)--;
 753
 754         tracing_on();
 755 }
 756
 757 static void
 758 traceoff_trigger(struct event_trigger_data *data)
 759 {
 760         if (!tracing_is_on())
 761                 return;
 762
 763         tracing_off();
 764 }
 765
 766 static void
 767 traceoff_count_trigger(struct event_trigger_data *data)
 768 {
 769         if (!tracing_is_on())
 770                 return;
 771
 772         if (!data->count)
 773                 return;
 774
 775         if (data->count != -1)
 776                 (data->count)--;
 777
 778         tracing_off();
 779 }
 780
 781 static int
 782 traceon_trigger_print(struct seq_file *m, struct event_trigger_ops *ops,
 783                       struct event_trigger_data *data)
 784 {
 785         return event_trigger_print("traceon", m, (void *)data->count,
 786                                    data->filter_str);
 787 }
 788
 789 static int
 790 traceoff_trigger_print(struct seq_file *m, struct event_trigger_ops *ops,
 791                        struct event_trigger_data *data)
 792 {
 793         return event_trigger_print("traceoff", m, (void *)data->count,
 794                                    data->filter_str);
 795 }
 796
 797 static struct event_trigger_ops traceon_trigger_ops = {
 798         .func                   = traceon_trigger,
 799         .print                  = traceon_trigger_print,
 800         .init                   = event_trigger_init,
 801         .free                   = event_trigger_free,
 802 };
 803
 804 static struct event_trigger_ops traceon_count_trigger_ops = {
 805         .func                   = traceon_count_trigger,
 806         .print                  = traceon_trigger_print,
 807         .init                   = event_trigger_init,
 808         .free                   = event_trigger_free,
 809 };
 810
 811 static struct event_trigger_ops traceoff_trigger_ops = {
 812         .func                   = traceoff_trigger,
 813         .print                  = traceoff_trigger_print,
 814         .init                   = event_trigger_init,
 815         .free                   = event_trigger_free,
 816 };
 817
 818 static struct event_trigger_ops traceoff_count_trigger_ops = {
 819         .func                   = traceoff_count_trigger,
 820         .print                  = traceoff_trigger_print,
 821         .init                   = event_trigger_init,
 822         .free                   = event_trigger_free,
 823 };
 824
 825 static struct event_trigger_ops *
 826 onoff_get_trigger_ops(char *cmd, char *param)
 827 {
 828         struct event_trigger_ops *ops;
 829
 830         /* we register both traceon and traceoff to this callback */
 831         if (strcmp(cmd, "traceon") == 0)
 832                 ops = param ? &traceon_count_trigger_ops :
 833                         &traceon_trigger_ops;
 834         else
 835                 ops = param ? &traceoff_count_trigger_ops :
 836                         &traceoff_trigger_ops;
 837
 838         return ops;
 839 }
 840
 841 static struct event_command trigger_traceon_cmd = {
 842         .name                   = "traceon",
 843         .trigger_type           = ETT_TRACE_ONOFF,
 844         .func                   = event_trigger_callback,
 845         .reg                    = register_trigger,
 846         .unreg                  = unregister_trigger,
 847         .get_trigger_ops        = onoff_get_trigger_ops,
 848         .set_filter             = set_trigger_filter,
 849 };
 850
 851 static struct event_command trigger_traceoff_cmd = {
 852         .name                   = "traceoff",
 853         .trigger_type           = ETT_TRACE_ONOFF,
 854         .func                   = event_trigger_callback,
 855         .reg                    = register_trigger,
 856         .unreg                  = unregister_trigger,
 857         .get_trigger_ops        = onoff_get_trigger_ops,
 858         .set_filter             = set_trigger_filter,
 859 };
 860
 861 #ifdef CONFIG_TRACER_SNAPSHOT
 862 static void
 863 snapshot_trigger(struct event_trigger_data *data)
 864 {
 865         tracing_snapshot();
 866 }
 867
 868 static void
 869 snapshot_count_trigger(struct event_trigger_data *data)
 870 {
 871         if (!data->count)
 872                 return;
 873
 874         if (data->count != -1)
 875                 (data->count)--;
 876
 877         snapshot_trigger(data);
 878 }
 879
 880 static int
 881 register_snapshot_trigger(char *glob, struct event_trigger_ops *ops,
 882                           struct event_trigger_data *data,
 883                           struct ftrace_event_file *file)
 884 {
 885         int ret = register_trigger(glob, ops, data, file);
 886
 887         if (ret > 0 && tracing_alloc_snapshot() != 0) {
 888                 unregister_trigger(glob, ops, data, file);
 889                 ret = 0;
 890         }
 891
 892         return ret;
 893 }
 894
 895 static int
 896 snapshot_trigger_print(struct seq_file *m, struct event_trigger_ops *ops,
 897                        struct event_trigger_data *data)
 898 {
 899         return event_trigger_print("snapshot", m, (void *)data->count,
 900                                    data->filter_str);
 901 }
 902
 903 static struct event_trigger_ops snapshot_trigger_ops = {
 904         .func                   = snapshot_trigger,
 905         .print                  = snapshot_trigger_print,
 906         .init                   = event_trigger_init,
 907         .free                   = event_trigger_free,
 908 };
 909
 910 static struct event_trigger_ops snapshot_count_trigger_ops = {
 911         .func                   = snapshot_count_trigger,
 912         .print                  = snapshot_trigger_print,
 913         .init                   = event_trigger_init,
 914         .free                   = event_trigger_free,
 915 };
 916
 917 static struct event_trigger_ops *
 918 snapshot_get_trigger_ops(char *cmd, char *param)
 919 {
 920         return param ? &snapshot_count_trigger_ops : &snapshot_trigger_ops;
 921 }
 922
 923 static struct event_command trigger_snapshot_cmd = {
 924         .name                   = "snapshot",
 925         .trigger_type           = ETT_SNAPSHOT,
 926         .func                   = event_trigger_callback,
 927         .reg                    = register_snapshot_trigger,
 928         .unreg                  = unregister_trigger,
 929         .get_trigger_ops        = snapshot_get_trigger_ops,
 930         .set_filter             = set_trigger_filter,
 931 };
 932
 933 static __init int register_trigger_snapshot_cmd(void)
 934 {
 935         int ret;
 936
 937         ret = register_event_command(&trigger_snapshot_cmd);
 938         WARN_ON(ret < 0);
 939
 940         return ret;
 941 }
 942 #else
 943 static __init int register_trigger_snapshot_cmd(void) { return 0; }
 944 #endif /* CONFIG_TRACER_SNAPSHOT */
 945
 946 #ifdef CONFIG_STACKTRACE
 947 /*
 948  * Skip 3:
 949  *   stacktrace_trigger()
 950  *   event_triggers_post_call()
 951  *   ftrace_raw_event_xxx()
 952  */
 953 #define STACK_SKIP 3
 954
 955 static void
 956 stacktrace_trigger(struct event_trigger_data *data)
 957 {
 958         trace_dump_stack(STACK_SKIP);
 959 }
 960
 961 static void
 962 stacktrace_count_trigger(struct event_trigger_data *data)
 963 {
 964         if (!data->count)
 965                 return;
 966
 967         if (data->count != -1)
 968                 (data->count)--;
 969
 970         stacktrace_trigger(data);
 971 }
 972
 973 static int
 974 stacktrace_trigger_print(struct seq_file *m, struct event_trigger_ops *ops,
 975                          struct event_trigger_data *data)
 976 {
 977         return event_trigger_print("stacktrace", m, (void *)data->count,
 978                                    data->filter_str);
 979 }
 980
 981 static struct event_trigger_ops stacktrace_trigger_ops = {
 982         .func                   = stacktrace_trigger,
 983         .print                  = stacktrace_trigger_print,
 984         .init                   = event_trigger_init,
 985         .free                   = event_trigger_free,
 986 };
 987
 988 static struct event_trigger_ops stacktrace_count_trigger_ops = {
 989         .func                   = stacktrace_count_trigger,
 990         .print                  = stacktrace_trigger_print,
 991         .init                   = event_trigger_init,
 992         .free                   = event_trigger_free,
 993 };
 994
 995 static struct event_trigger_ops *
 996 stacktrace_get_trigger_ops(char *cmd, char *param)
 997 {
 998         return param ? &stacktrace_count_trigger_ops : &stacktrace_trigger_ops;
 999 }
1000
1001 static struct event_command trigger_stacktrace_cmd = {
1002         .name                   = "stacktrace",
1003         .trigger_type           = ETT_STACKTRACE,
1004         .post_trigger           = true,
1005         .func                   = event_trigger_callback,
1006         .reg                    = register_trigger,
1007         .unreg                  = unregister_trigger,
1008         .get_trigger_ops        = stacktrace_get_trigger_ops,
1009         .set_filter             = set_trigger_filter,
1010 };
1011
1012 static __init int register_trigger_stacktrace_cmd(void)
1013 {
1014         int ret;
1015
1016         ret = register_event_command(&trigger_stacktrace_cmd);
1017         WARN_ON(ret < 0);
1018
1019         return ret;
1020 }
1021 #else
1022 static __init int register_trigger_stacktrace_cmd(void) { return 0; }
1023 #endif /* CONFIG_STACKTRACE */
1024
1025 static __init void unregister_trigger_traceon_traceoff_cmds(void)
1026 {
1027         unregister_event_command(&trigger_traceon_cmd);
1028         unregister_event_command(&trigger_traceoff_cmd);
1029 }
1030
1031 /* Avoid typos */
1032 #define ENABLE_EVENT_STR        "enable_event"
1033 #define DISABLE_EVENT_STR       "disable_event"
1034
1035 struct enable_trigger_data {
1036         struct ftrace_event_file        *file;
1037         bool                            enable;
1038 };
1039
1040 static void
1041 event_enable_trigger(struct event_trigger_data *data)
1042 {
1043         struct enable_trigger_data *enable_data = data->private_data;
1044
1045         if (enable_data->enable)
1046                 clear_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &enable_data->file->flags);
1047         else
1048                 set_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &enable_data->file->flags);
1049 }
1050
1051 static void
1052 event_enable_count_trigger(struct event_trigger_data *data)
1053 {
1054         struct enable_trigger_data *enable_data = data->private_data;
1055
1056         if (!data->count)
1057                 return;
1058
1059         /* Skip if the event is in a state we want to switch to */
1060         if (enable_data->enable == !(enable_data->file->flags & FTRACE_EVENT_FL_SOFT_DISABLED))
1061                 return;
1062
1063         if (data->count != -1)
1064                 (data->count)--;
1065
1066         event_enable_trigger(data);
1067 }
1068
1069 static int
1070 event_enable_trigger_print(struct seq_file *m, struct event_trigger_ops *ops,
1071                            struct event_trigger_data *data)
1072 {
1073         struct enable_trigger_data *enable_data = data->private_data;
1074
1075         seq_printf(m, "%s:%s:%s",
1076                    enable_data->enable ? ENABLE_EVENT_STR : DISABLE_EVENT_STR,
1077                    enable_data->file->event_call->class->system,
1078                    enable_data->file->event_call->name);
1079
1080         if (data->count == -1)
1081                 seq_puts(m, ":unlimited");
1082         else
1083                 seq_printf(m, ":count=%ld", data->count);
1084
1085         if (data->filter_str)
1086                 seq_printf(m, " if %s\n", data->filter_str);
1087         else
1088                 seq_puts(m, "\n");
1089
1090         return 0;
1091 }
1092
1093 static void
1094 event_enable_trigger_free(struct event_trigger_ops *ops,
1095                           struct event_trigger_data *data)
1096 {
1097         struct enable_trigger_data *enable_data = data->private_data;
1098
1099         if (WARN_ON_ONCE(data->ref <= 0))
1100                 return;
1101
1102         data->ref--;
1103         if (!data->ref) {
1104                 /* Remove the SOFT_MODE flag */
1105                 trace_event_enable_disable(enable_data->file, 0, 1);
1106                 module_put(enable_data->file->event_call->mod);
1107                 trigger_data_free(data);
1108                 kfree(enable_data);
1109         }
1110 }
1111
1112 static struct event_trigger_ops event_enable_trigger_ops = {
1113         .func                   = event_enable_trigger,
1114         .print                  = event_enable_trigger_print,
1115         .init                   = event_trigger_init,
1116         .free                   = event_enable_trigger_free,
1117 };
1118
1119 static struct event_trigger_ops event_enable_count_trigger_ops = {
1120         .func                   = event_enable_count_trigger,
1121         .print                  = event_enable_trigger_print,
1122         .init                   = event_trigger_init,
1123         .free                   = event_enable_trigger_free,
1124 };
1125
1126 static struct event_trigger_ops event_disable_trigger_ops = {
1127         .func                   = event_enable_trigger,
1128         .print                  = event_enable_trigger_print,
1129         .init                   = event_trigger_init,
1130         .free                   = event_enable_trigger_free,
1131 };
1132
1133 static struct event_trigger_ops event_disable_count_trigger_ops = {
1134         .func                   = event_enable_count_trigger,
1135         .print                  = event_enable_trigger_print,
1136         .init                   = event_trigger_init,
1137         .free                   = event_enable_trigger_free,
1138 };
1139
1140 static int
1141 event_enable_trigger_func(struct event_command *cmd_ops,
1142                           struct ftrace_event_file *file,
1143                           char *glob, char *cmd, char *param)
1144 {
1145         struct ftrace_event_file *event_enable_file;
1146         struct enable_trigger_data *enable_data;
1147         struct event_trigger_data *trigger_data;
1148         struct event_trigger_ops *trigger_ops;
1149         struct trace_array *tr = file->tr;
1150         const char *system;
1151         const char *event;
1152         char *trigger;
1153         char *number;
1154         bool enable;
1155         int ret;
1156
1157         if (!param)
1158                 return -EINVAL;
1159
1160         /* separate the trigger from the filter (s:e:n [if filter]) */
1161         trigger = strsep(&param, " \t");
1162         if (!trigger)
1163                 return -EINVAL;
1164
1165         system = strsep(&trigger, ":");
1166         if (!trigger)
1167                 return -EINVAL;
1168
1169         event = strsep(&trigger, ":");
1170
1171         ret = -EINVAL;
1172         event_enable_file = find_event_file(tr, system, event);
1173         if (!event_enable_file)
1174                 goto out;
1175
1176         enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
1177
1178         trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);
1179
1180         ret = -ENOMEM;
1181         trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
1182         if (!trigger_data)
1183                 goto out;
1184
1185         enable_data = kzalloc(sizeof(*enable_data), GFP_KERNEL);
1186         if (!enable_data) {
1187                 kfree(trigger_data);
1188                 goto out;
1189         }
1190
1191         trigger_data->count = -1;
1192         trigger_data->ops = trigger_ops;
1193         trigger_data->cmd_ops = cmd_ops;
1194         INIT_LIST_HEAD(&trigger_data->list);
1195         RCU_INIT_POINTER(trigger_data->filter, NULL);
1196
1197         enable_data->enable = enable;
1198         enable_data->file = event_enable_file;
1199         trigger_data->private_data = enable_data;
1200
1201         if (glob[0] == '!') {
1202                 cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file);
1203                 kfree(trigger_data);
1204                 kfree(enable_data);
1205                 ret = 0;
1206                 goto out;
1207         }
1208
1209         if (trigger) {
1210                 number = strsep(&trigger, ":");
1211
1212                 ret = -EINVAL;
1213                 if (!strlen(number))
1214                         goto out_free;
1215
1216                 /*
1217                  * We use the callback data field (which is a pointer)
1218                  * as our counter.
1219                  */
1220                 ret = kstrtoul(number, 0, &trigger_data->count);
1221                 if (ret)
1222                         goto out_free;
1223         }
1224
1225         if (!param) /* if param is non-empty, it's supposed to be a filter */
1226                 goto out_reg;
1227
1228         if (!cmd_ops->set_filter)
1229                 goto out_reg;
1230
1231         ret = cmd_ops->set_filter(param, trigger_data, file);
1232         if (ret < 0)
1233                 goto out_free;
1234
1235  out_reg:
1236         /* Don't let event modules unload while probe registered */
1237         ret = try_module_get(event_enable_file->event_call->mod);
1238         if (!ret) {
1239                 ret = -EBUSY;
1240                 goto out_free;
1241         }
1242
1243         ret = trace_event_enable_disable(event_enable_file, 1, 1);
1244         if (ret < 0)
1245                 goto out_put;
1246         ret = cmd_ops->reg(glob, trigger_ops, trigger_data, file);
1247         /*
1248          * The above returns on success the # of functions enabled,
1249          * but if it didn't find any functions it returns zero.
1250          * Consider no functions a failure too.
1251          */
1252         if (!ret) {
1253                 ret = -ENOENT;
1254                 goto out_disable;
1255         } else if (ret < 0)
1256                 goto out_disable;
1257         /* Just return zero, not the number of enabled functions */
1258         ret = 0;
1259  out:
1260         return ret;
1261
1262  out_disable:
1263         trace_event_enable_disable(event_enable_file, 0, 1);
1264  out_put:
1265         module_put(event_enable_file->event_call->mod);
1266  out_free:
1267         if (cmd_ops->set_filter)
1268                 cmd_ops->set_filter(NULL, trigger_data, NULL);
1269         kfree(trigger_data);
1270         kfree(enable_data);
1271         goto out;
1272 }
1273
1274 static int event_enable_register_trigger(char *glob,
1275                                          struct event_trigger_ops *ops,
1276                                          struct event_trigger_data *data,
1277                                          struct ftrace_event_file *file)
1278 {
1279         struct enable_trigger_data *enable_data = data->private_data;
1280         struct enable_trigger_data *test_enable_data;
1281         struct event_trigger_data *test;
1282         int ret = 0;
1283
1284         list_for_each_entry_rcu(test, &file->triggers, list) {
1285                 test_enable_data = test->private_data;
1286                 if (test_enable_data &&
1287                     (test_enable_data->file == enable_data->file)) {
1288                         ret = -EEXIST;
1289                         goto out;
1290                 }
1291         }
1292
1293         if (data->ops->init) {
1294                 ret = data->ops->init(data->ops, data);
1295                 if (ret < 0)
1296                         goto out;
1297         }
1298
1299         list_add_rcu(&data->list, &file->triggers);
1300         ret++;
1301
1302         if (trace_event_trigger_enable_disable(file, 1) < 0) {
1303                 list_del_rcu(&data->list);
1304                 ret--;
1305         }
1306         update_cond_flag(file);
1307 out:
1308         return ret;
1309 }
1310
1311 static void event_enable_unregister_trigger(char *glob,
1312                                             struct event_trigger_ops *ops,
1313                                             struct event_trigger_data *test,
1314                                             struct ftrace_event_file *file)
1315 {
1316         struct enable_trigger_data *test_enable_data = test->private_data;
1317         struct enable_trigger_data *enable_data;
1318         struct event_trigger_data *data;
1319         bool unregistered = false;
1320
1321         list_for_each_entry_rcu(data, &file->triggers, list) {
1322                 enable_data = data->private_data;
1323                 if (enable_data &&
1324                     (enable_data->file == test_enable_data->file)) {
1325                         unregistered = true;
1326                         list_del_rcu(&data->list);
1327                         update_cond_flag(file);
1328                         trace_event_trigger_enable_disable(file, 0);
1329                         break;
1330                 }
1331         }
1332
1333         if (unregistered && data->ops->free)
1334                 data->ops->free(data->ops, data);
1335 }
1336
1337 static struct event_trigger_ops *
1338 event_enable_get_trigger_ops(char *cmd, char *param)
1339 {
1340         struct event_trigger_ops *ops;
1341         bool enable;
1342
1343         enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
1344
1345         if (enable)
1346                 ops = param ? &event_enable_count_trigger_ops :
1347                         &event_enable_trigger_ops;
1348         else
1349                 ops = param ? &event_disable_count_trigger_ops :
1350                         &event_disable_trigger_ops;
1351
1352         return ops;
1353 }
1354
1355 static struct event_command trigger_enable_cmd = {
1356         .name                   = ENABLE_EVENT_STR,
1357         .trigger_type           = ETT_EVENT_ENABLE,
1358         .func                   = event_enable_trigger_func,
1359         .reg                    = event_enable_register_trigger,
1360         .unreg                  = event_enable_unregister_trigger,
1361         .get_trigger_ops        = event_enable_get_trigger_ops,
1362         .set_filter             = set_trigger_filter,
1363 };
1364
1365 static struct event_command trigger_disable_cmd = {
1366         .name                   = DISABLE_EVENT_STR,
1367         .trigger_type           = ETT_EVENT_ENABLE,
1368         .func                   = event_enable_trigger_func,
1369         .reg                    = event_enable_register_trigger,
1370         .unreg                  = event_enable_unregister_trigger,
1371         .get_trigger_ops        = event_enable_get_trigger_ops,
1372         .set_filter             = set_trigger_filter,
1373 };
1374
1375 static __init void unregister_trigger_enable_disable_cmds(void)
1376 {
1377         unregister_event_command(&trigger_enable_cmd);
1378         unregister_event_command(&trigger_disable_cmd);
1379 }
1380
1381 static __init int register_trigger_enable_disable_cmds(void)
1382 {
1383         int ret;
1384
1385         ret = register_event_command(&trigger_enable_cmd);
1386         if (WARN_ON(ret < 0))
1387                 return ret;
1388         ret = register_event_command(&trigger_disable_cmd);
1389         if (WARN_ON(ret < 0))
1390                 unregister_trigger_enable_disable_cmds();
1391
1392         return ret;
1393 }
1394
1395 static __init int register_trigger_traceon_traceoff_cmds(void)
1396 {
1397         int ret;
1398
1399         ret = register_event_command(&trigger_traceon_cmd);
1400         if (WARN_ON(ret < 0))
1401                 return ret;
1402         ret = register_event_command(&trigger_traceoff_cmd);
1403         if (WARN_ON(ret < 0))
1404                 unregister_trigger_traceon_traceoff_cmds();
1405
1406         return ret;
1407 }
1408
1409 __init int register_trigger_cmds(void)
1410 {
1411         register_trigger_traceon_traceoff_cmds();
1412         register_trigger_snapshot_cmd();
1413         register_trigger_stacktrace_cmd();
1414         register_trigger_enable_disable_cmds();
1415
1416         return 0;
1417 }