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