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