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