1
2
3
4
5
6
7
8#include <linux/security.h>
9#include <linux/module.h>
10#include <linux/ctype.h>
11#include <linux/mutex.h>
12#include <linux/slab.h>
13#include <linux/rculist.h>
14
15#include "trace.h"
16
17static LIST_HEAD(trigger_commands);
18static DEFINE_MUTEX(trigger_cmd_mutex);
19
20void trigger_data_free(struct event_trigger_data *data)
21{
22 if (data->cmd_ops->set_filter)
23 data->cmd_ops->set_filter(NULL, data, NULL);
24
25
26 tracepoint_synchronize_unregister();
27
28 kfree(data);
29}
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55enum event_trigger_type
56event_triggers_call(struct trace_event_file *file,
57 struct trace_buffer *buffer, void *rec,
58 struct ring_buffer_event *event)
59{
60 struct event_trigger_data *data;
61 enum event_trigger_type tt = ETT_NONE;
62 struct event_filter *filter;
63
64 if (list_empty(&file->triggers))
65 return tt;
66
67 list_for_each_entry_rcu(data, &file->triggers, list) {
68 if (data->paused)
69 continue;
70 if (!rec) {
71 data->ops->func(data, buffer, rec, event);
72 continue;
73 }
74 filter = rcu_dereference_sched(data->filter);
75 if (filter && !filter_match_preds(filter, rec))
76 continue;
77 if (event_command_post_trigger(data->cmd_ops)) {
78 tt |= data->cmd_ops->trigger_type;
79 continue;
80 }
81 data->ops->func(data, buffer, rec, event);
82 }
83 return tt;
84}
85EXPORT_SYMBOL_GPL(event_triggers_call);
86
87
88
89
90
91
92
93
94
95
96
97
98
99void
100event_triggers_post_call(struct trace_event_file *file,
101 enum event_trigger_type tt)
102{
103 struct event_trigger_data *data;
104
105 list_for_each_entry_rcu(data, &file->triggers, list) {
106 if (data->paused)
107 continue;
108 if (data->cmd_ops->trigger_type & tt)
109 data->ops->func(data, NULL, NULL, NULL);
110 }
111}
112EXPORT_SYMBOL_GPL(event_triggers_post_call);
113
114#define SHOW_AVAILABLE_TRIGGERS (void *)(1UL)
115
116static void *trigger_next(struct seq_file *m, void *t, loff_t *pos)
117{
118 struct trace_event_file *event_file = event_file_data(m->private);
119
120 if (t == SHOW_AVAILABLE_TRIGGERS) {
121 (*pos)++;
122 return NULL;
123 }
124 return seq_list_next(t, &event_file->triggers, pos);
125}
126
127static bool check_user_trigger(struct trace_event_file *file)
128{
129 struct event_trigger_data *data;
130
131 list_for_each_entry_rcu(data, &file->triggers, list) {
132 if (data->flags & EVENT_TRIGGER_FL_PROBE)
133 continue;
134 return true;
135 }
136 return false;
137}
138
139static void *trigger_start(struct seq_file *m, loff_t *pos)
140{
141 struct trace_event_file *event_file;
142
143
144 mutex_lock(&event_mutex);
145 event_file = event_file_data(m->private);
146 if (unlikely(!event_file))
147 return ERR_PTR(-ENODEV);
148
149 if (list_empty(&event_file->triggers) || !check_user_trigger(event_file))
150 return *pos == 0 ? SHOW_AVAILABLE_TRIGGERS : NULL;
151
152 return seq_list_start(&event_file->triggers, *pos);
153}
154
155static void trigger_stop(struct seq_file *m, void *t)
156{
157 mutex_unlock(&event_mutex);
158}
159
160static int trigger_show(struct seq_file *m, void *v)
161{
162 struct event_trigger_data *data;
163 struct event_command *p;
164
165 if (v == SHOW_AVAILABLE_TRIGGERS) {
166 seq_puts(m, "# Available triggers:\n");
167 seq_putc(m, '#');
168 mutex_lock(&trigger_cmd_mutex);
169 list_for_each_entry_reverse(p, &trigger_commands, list)
170 seq_printf(m, " %s", p->name);
171 seq_putc(m, '\n');
172 mutex_unlock(&trigger_cmd_mutex);
173 return 0;
174 }
175
176 data = list_entry(v, struct event_trigger_data, list);
177 data->ops->print(m, data->ops, data);
178
179 return 0;
180}
181
182static const struct seq_operations event_triggers_seq_ops = {
183 .start = trigger_start,
184 .next = trigger_next,
185 .stop = trigger_stop,
186 .show = trigger_show,
187};
188
189static int event_trigger_regex_open(struct inode *inode, struct file *file)
190{
191 int ret;
192
193 ret = security_locked_down(LOCKDOWN_TRACEFS);
194 if (ret)
195 return ret;
196
197 mutex_lock(&event_mutex);
198
199 if (unlikely(!event_file_data(file))) {
200 mutex_unlock(&event_mutex);
201 return -ENODEV;
202 }
203
204 if ((file->f_mode & FMODE_WRITE) &&
205 (file->f_flags & O_TRUNC)) {
206 struct trace_event_file *event_file;
207 struct event_command *p;
208
209 event_file = event_file_data(file);
210
211 list_for_each_entry(p, &trigger_commands, list) {
212 if (p->unreg_all)
213 p->unreg_all(event_file);
214 }
215 }
216
217 if (file->f_mode & FMODE_READ) {
218 ret = seq_open(file, &event_triggers_seq_ops);
219 if (!ret) {
220 struct seq_file *m = file->private_data;
221 m->private = file;
222 }
223 }
224
225 mutex_unlock(&event_mutex);
226
227 return ret;
228}
229
230int trigger_process_regex(struct trace_event_file *file, char *buff)
231{
232 char *command, *next;
233 struct event_command *p;
234 int ret = -EINVAL;
235
236 next = buff = skip_spaces(buff);
237 command = strsep(&next, ": \t");
238 if (next) {
239 next = skip_spaces(next);
240 if (!*next)
241 next = NULL;
242 }
243 command = (command[0] != '!') ? command : command + 1;
244
245 mutex_lock(&trigger_cmd_mutex);
246 list_for_each_entry(p, &trigger_commands, list) {
247 if (strcmp(p->name, command) == 0) {
248 ret = p->func(p, file, buff, command, next);
249 goto out_unlock;
250 }
251 }
252 out_unlock:
253 mutex_unlock(&trigger_cmd_mutex);
254
255 return ret;
256}
257
258static ssize_t event_trigger_regex_write(struct file *file,
259 const char __user *ubuf,
260 size_t cnt, loff_t *ppos)
261{
262 struct trace_event_file *event_file;
263 ssize_t ret;
264 char *buf;
265
266 if (!cnt)
267 return 0;
268
269 if (cnt >= PAGE_SIZE)
270 return -EINVAL;
271
272 buf = memdup_user_nul(ubuf, cnt);
273 if (IS_ERR(buf))
274 return PTR_ERR(buf);
275
276 strim(buf);
277
278 mutex_lock(&event_mutex);
279 event_file = event_file_data(file);
280 if (unlikely(!event_file)) {
281 mutex_unlock(&event_mutex);
282 kfree(buf);
283 return -ENODEV;
284 }
285 ret = trigger_process_regex(event_file, buf);
286 mutex_unlock(&event_mutex);
287
288 kfree(buf);
289 if (ret < 0)
290 goto out;
291
292 *ppos += cnt;
293 ret = cnt;
294 out:
295 return ret;
296}
297
298static int event_trigger_regex_release(struct inode *inode, struct file *file)
299{
300 mutex_lock(&event_mutex);
301
302 if (file->f_mode & FMODE_READ)
303 seq_release(inode, file);
304
305 mutex_unlock(&event_mutex);
306
307 return 0;
308}
309
310static ssize_t
311event_trigger_write(struct file *filp, const char __user *ubuf,
312 size_t cnt, loff_t *ppos)
313{
314 return event_trigger_regex_write(filp, ubuf, cnt, ppos);
315}
316
317static int
318event_trigger_open(struct inode *inode, struct file *filp)
319{
320
321 return event_trigger_regex_open(inode, filp);
322}
323
324static int
325event_trigger_release(struct inode *inode, struct file *file)
326{
327 return event_trigger_regex_release(inode, file);
328}
329
330const struct file_operations event_trigger_fops = {
331 .open = event_trigger_open,
332 .read = seq_read,
333 .write = event_trigger_write,
334 .llseek = tracing_lseek,
335 .release = event_trigger_release,
336};
337
338
339
340
341
342__init int register_event_command(struct event_command *cmd)
343{
344 struct event_command *p;
345 int ret = 0;
346
347 mutex_lock(&trigger_cmd_mutex);
348 list_for_each_entry(p, &trigger_commands, list) {
349 if (strcmp(cmd->name, p->name) == 0) {
350 ret = -EBUSY;
351 goto out_unlock;
352 }
353 }
354 list_add(&cmd->list, &trigger_commands);
355 out_unlock:
356 mutex_unlock(&trigger_cmd_mutex);
357
358 return ret;
359}
360
361
362
363
364
365__init int unregister_event_command(struct event_command *cmd)
366{
367 struct event_command *p, *n;
368 int ret = -ENODEV;
369
370 mutex_lock(&trigger_cmd_mutex);
371 list_for_each_entry_safe(p, n, &trigger_commands, list) {
372 if (strcmp(cmd->name, p->name) == 0) {
373 ret = 0;
374 list_del_init(&p->list);
375 goto out_unlock;
376 }
377 }
378 out_unlock:
379 mutex_unlock(&trigger_cmd_mutex);
380
381 return ret;
382}
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398static int
399event_trigger_print(const char *name, struct seq_file *m,
400 void *data, char *filter_str)
401{
402 long count = (long)data;
403
404 seq_puts(m, name);
405
406 if (count == -1)
407 seq_puts(m, ":unlimited");
408 else
409 seq_printf(m, ":count=%ld", count);
410
411 if (filter_str)
412 seq_printf(m, " if %s\n", filter_str);
413 else
414 seq_putc(m, '\n');
415
416 return 0;
417}
418
419
420
421
422
423
424
425
426
427
428
429
430
431int event_trigger_init(struct event_trigger_ops *ops,
432 struct event_trigger_data *data)
433{
434 data->ref++;
435 return 0;
436}
437
438
439
440
441
442
443
444
445
446
447
448static void
449event_trigger_free(struct event_trigger_ops *ops,
450 struct event_trigger_data *data)
451{
452 if (WARN_ON_ONCE(data->ref <= 0))
453 return;
454
455 data->ref--;
456 if (!data->ref)
457 trigger_data_free(data);
458}
459
460int trace_event_trigger_enable_disable(struct trace_event_file *file,
461 int trigger_enable)
462{
463 int ret = 0;
464
465 if (trigger_enable) {
466 if (atomic_inc_return(&file->tm_ref) > 1)
467 return ret;
468 set_bit(EVENT_FILE_FL_TRIGGER_MODE_BIT, &file->flags);
469 ret = trace_event_enable_disable(file, 1, 1);
470 } else {
471 if (atomic_dec_return(&file->tm_ref) > 0)
472 return ret;
473 clear_bit(EVENT_FILE_FL_TRIGGER_MODE_BIT, &file->flags);
474 ret = trace_event_enable_disable(file, 0, 1);
475 }
476
477 return ret;
478}
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493void
494clear_event_triggers(struct trace_array *tr)
495{
496 struct trace_event_file *file;
497
498 list_for_each_entry(file, &tr->events, list) {
499 struct event_trigger_data *data, *n;
500 list_for_each_entry_safe(data, n, &file->triggers, list) {
501 trace_event_trigger_enable_disable(file, 0);
502 list_del_rcu(&data->list);
503 if (data->ops->free)
504 data->ops->free(data->ops, data);
505 }
506 }
507}
508
509
510
511
512
513
514
515
516
517
518
519void update_cond_flag(struct trace_event_file *file)
520{
521 struct event_trigger_data *data;
522 bool set_cond = false;
523
524 lockdep_assert_held(&event_mutex);
525
526 list_for_each_entry(data, &file->triggers, list) {
527 if (data->filter || event_command_post_trigger(data->cmd_ops) ||
528 event_command_needs_rec(data->cmd_ops)) {
529 set_cond = true;
530 break;
531 }
532 }
533
534 if (set_cond)
535 set_bit(EVENT_FILE_FL_TRIGGER_COND_BIT, &file->flags);
536 else
537 clear_bit(EVENT_FILE_FL_TRIGGER_COND_BIT, &file->flags);
538}
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554static int register_trigger(char *glob, struct event_trigger_ops *ops,
555 struct event_trigger_data *data,
556 struct trace_event_file *file)
557{
558 struct event_trigger_data *test;
559 int ret = 0;
560
561 lockdep_assert_held(&event_mutex);
562
563 list_for_each_entry(test, &file->triggers, list) {
564 if (test->cmd_ops->trigger_type == data->cmd_ops->trigger_type) {
565 ret = -EEXIST;
566 goto out;
567 }
568 }
569
570 if (data->ops->init) {
571 ret = data->ops->init(data->ops, data);
572 if (ret < 0)
573 goto out;
574 }
575
576 list_add_rcu(&data->list, &file->triggers);
577 ret++;
578
579 update_cond_flag(file);
580 if (trace_event_trigger_enable_disable(file, 1) < 0) {
581 list_del_rcu(&data->list);
582 update_cond_flag(file);
583 ret--;
584 }
585out:
586 return ret;
587}
588
589
590
591
592
593
594
595
596
597
598
599
600
601static void unregister_trigger(char *glob, struct event_trigger_ops *ops,
602 struct event_trigger_data *test,
603 struct trace_event_file *file)
604{
605 struct event_trigger_data *data;
606 bool unregistered = false;
607
608 lockdep_assert_held(&event_mutex);
609
610 list_for_each_entry(data, &file->triggers, list) {
611 if (data->cmd_ops->trigger_type == test->cmd_ops->trigger_type) {
612 unregistered = true;
613 list_del_rcu(&data->list);
614 trace_event_trigger_enable_disable(file, 0);
615 update_cond_flag(file);
616 break;
617 }
618 }
619
620 if (unregistered && data->ops->free)
621 data->ops->free(data->ops, data);
622}
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640static int
641event_trigger_callback(struct event_command *cmd_ops,
642 struct trace_event_file *file,
643 char *glob, char *cmd, char *param)
644{
645 struct event_trigger_data *trigger_data;
646 struct event_trigger_ops *trigger_ops;
647 char *trigger = NULL;
648 char *number;
649 int ret;
650
651
652 if (param && isdigit(param[0])) {
653 trigger = strsep(¶m, " \t");
654 if (param) {
655 param = skip_spaces(param);
656 if (!*param)
657 param = NULL;
658 }
659 }
660
661 trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);
662
663 ret = -ENOMEM;
664 trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
665 if (!trigger_data)
666 goto out;
667
668 trigger_data->count = -1;
669 trigger_data->ops = trigger_ops;
670 trigger_data->cmd_ops = cmd_ops;
671 trigger_data->private_data = file;
672 INIT_LIST_HEAD(&trigger_data->list);
673 INIT_LIST_HEAD(&trigger_data->named_list);
674
675 if (glob[0] == '!') {
676 cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file);
677 kfree(trigger_data);
678 ret = 0;
679 goto out;
680 }
681
682 if (trigger) {
683 number = strsep(&trigger, ":");
684
685 ret = -EINVAL;
686 if (!strlen(number))
687 goto out_free;
688
689
690
691
692
693 ret = kstrtoul(number, 0, &trigger_data->count);
694 if (ret)
695 goto out_free;
696 }
697
698 if (!param)
699 goto out_reg;
700
701 if (!cmd_ops->set_filter)
702 goto out_reg;
703
704 ret = cmd_ops->set_filter(param, trigger_data, file);
705 if (ret < 0)
706 goto out_free;
707
708 out_reg:
709
710 event_trigger_init(trigger_ops, trigger_data);
711 ret = cmd_ops->reg(glob, trigger_ops, trigger_data, file);
712
713
714
715
716
717 if (!ret) {
718 cmd_ops->unreg(glob, trigger_ops, trigger_data, file);
719 ret = -ENOENT;
720 } else if (ret > 0)
721 ret = 0;
722
723
724 event_trigger_free(trigger_ops, trigger_data);
725 out:
726 return ret;
727
728 out_free:
729 if (cmd_ops->set_filter)
730 cmd_ops->set_filter(NULL, trigger_data, NULL);
731 kfree(trigger_data);
732 goto out;
733}
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751int set_trigger_filter(char *filter_str,
752 struct event_trigger_data *trigger_data,
753 struct trace_event_file *file)
754{
755 struct event_trigger_data *data = trigger_data;
756 struct event_filter *filter = NULL, *tmp;
757 int ret = -EINVAL;
758 char *s;
759
760 if (!filter_str)
761 goto assign;
762
763 s = strsep(&filter_str, " \t");
764
765 if (!strlen(s) || strcmp(s, "if") != 0)
766 goto out;
767
768 if (!filter_str)
769 goto out;
770
771
772 ret = create_event_filter(file->tr, file->event_call,
773 filter_str, false, &filter);
774
775
776
777
778 assign:
779 tmp = rcu_access_pointer(data->filter);
780
781 rcu_assign_pointer(data->filter, filter);
782
783 if (tmp) {
784
785 tracepoint_synchronize_unregister();
786 free_event_filter(tmp);
787 }
788
789 kfree(data->filter_str);
790 data->filter_str = NULL;
791
792 if (filter_str) {
793 data->filter_str = kstrdup(filter_str, GFP_KERNEL);
794 if (!data->filter_str) {
795 free_event_filter(rcu_access_pointer(data->filter));
796 data->filter = NULL;
797 ret = -ENOMEM;
798 }
799 }
800 out:
801 return ret;
802}
803
804static LIST_HEAD(named_triggers);
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820struct event_trigger_data *find_named_trigger(const char *name)
821{
822 struct event_trigger_data *data;
823
824 if (!name)
825 return NULL;
826
827 list_for_each_entry(data, &named_triggers, named_list) {
828 if (data->named_data)
829 continue;
830 if (strcmp(data->name, name) == 0)
831 return data;
832 }
833
834 return NULL;
835}
836
837
838
839
840
841
842
843bool is_named_trigger(struct event_trigger_data *test)
844{
845 struct event_trigger_data *data;
846
847 list_for_each_entry(data, &named_triggers, named_list) {
848 if (test == data)
849 return true;
850 }
851
852 return false;
853}
854
855
856
857
858
859
860
861
862int save_named_trigger(const char *name, struct event_trigger_data *data)
863{
864 data->name = kstrdup(name, GFP_KERNEL);
865 if (!data->name)
866 return -ENOMEM;
867
868 list_add(&data->named_list, &named_triggers);
869
870 return 0;
871}
872
873
874
875
876
877void del_named_trigger(struct event_trigger_data *data)
878{
879 kfree(data->name);
880 data->name = NULL;
881
882 list_del(&data->named_list);
883}
884
885static void __pause_named_trigger(struct event_trigger_data *data, bool pause)
886{
887 struct event_trigger_data *test;
888
889 list_for_each_entry(test, &named_triggers, named_list) {
890 if (strcmp(test->name, data->name) == 0) {
891 if (pause) {
892 test->paused_tmp = test->paused;
893 test->paused = true;
894 } else {
895 test->paused = test->paused_tmp;
896 }
897 }
898 }
899}
900
901
902
903
904
905
906
907
908
909
910void pause_named_trigger(struct event_trigger_data *data)
911{
912 __pause_named_trigger(data, true);
913}
914
915
916
917
918
919
920
921
922
923
924void unpause_named_trigger(struct event_trigger_data *data)
925{
926 __pause_named_trigger(data, false);
927}
928
929
930
931
932
933
934
935
936
937
938
939
940
941void set_named_trigger_data(struct event_trigger_data *data,
942 struct event_trigger_data *named_data)
943{
944 data->named_data = named_data;
945}
946
947struct event_trigger_data *
948get_named_trigger_data(struct event_trigger_data *data)
949{
950 return data->named_data;
951}
952
953static void
954traceon_trigger(struct event_trigger_data *data,
955 struct trace_buffer *buffer, void *rec,
956 struct ring_buffer_event *event)
957{
958 if (tracing_is_on())
959 return;
960
961 tracing_on();
962}
963
964static void
965traceon_count_trigger(struct event_trigger_data *data,
966 struct trace_buffer *buffer, void *rec,
967 struct ring_buffer_event *event)
968{
969 if (tracing_is_on())
970 return;
971
972 if (!data->count)
973 return;
974
975 if (data->count != -1)
976 (data->count)--;
977
978 tracing_on();
979}
980
981static void
982traceoff_trigger(struct event_trigger_data *data,
983 struct trace_buffer *buffer, void *rec,
984 struct ring_buffer_event *event)
985{
986 if (!tracing_is_on())
987 return;
988
989 tracing_off();
990}
991
992static void
993traceoff_count_trigger(struct event_trigger_data *data,
994 struct trace_buffer *buffer, void *rec,
995 struct ring_buffer_event *event)
996{
997 if (!tracing_is_on())
998 return;
999
1000 if (!data->count)
1001 return;
1002
1003 if (data->count != -1)
1004 (data->count)--;
1005
1006 tracing_off();
1007}
1008
1009static int
1010traceon_trigger_print(struct seq_file *m, struct event_trigger_ops *ops,
1011 struct event_trigger_data *data)
1012{
1013 return event_trigger_print("traceon", m, (void *)data->count,
1014 data->filter_str);
1015}
1016
1017static int
1018traceoff_trigger_print(struct seq_file *m, struct event_trigger_ops *ops,
1019 struct event_trigger_data *data)
1020{
1021 return event_trigger_print("traceoff", m, (void *)data->count,
1022 data->filter_str);
1023}
1024
1025static struct event_trigger_ops traceon_trigger_ops = {
1026 .func = traceon_trigger,
1027 .print = traceon_trigger_print,
1028 .init = event_trigger_init,
1029 .free = event_trigger_free,
1030};
1031
1032static struct event_trigger_ops traceon_count_trigger_ops = {
1033 .func = traceon_count_trigger,
1034 .print = traceon_trigger_print,
1035 .init = event_trigger_init,
1036 .free = event_trigger_free,
1037};
1038
1039static struct event_trigger_ops traceoff_trigger_ops = {
1040 .func = traceoff_trigger,
1041 .print = traceoff_trigger_print,
1042 .init = event_trigger_init,
1043 .free = event_trigger_free,
1044};
1045
1046static struct event_trigger_ops traceoff_count_trigger_ops = {
1047 .func = traceoff_count_trigger,
1048 .print = traceoff_trigger_print,
1049 .init = event_trigger_init,
1050 .free = event_trigger_free,
1051};
1052
1053static struct event_trigger_ops *
1054onoff_get_trigger_ops(char *cmd, char *param)
1055{
1056 struct event_trigger_ops *ops;
1057
1058
1059 if (strcmp(cmd, "traceon") == 0)
1060 ops = param ? &traceon_count_trigger_ops :
1061 &traceon_trigger_ops;
1062 else
1063 ops = param ? &traceoff_count_trigger_ops :
1064 &traceoff_trigger_ops;
1065
1066 return ops;
1067}
1068
1069static struct event_command trigger_traceon_cmd = {
1070 .name = "traceon",
1071 .trigger_type = ETT_TRACE_ONOFF,
1072 .func = event_trigger_callback,
1073 .reg = register_trigger,
1074 .unreg = unregister_trigger,
1075 .get_trigger_ops = onoff_get_trigger_ops,
1076 .set_filter = set_trigger_filter,
1077};
1078
1079static struct event_command trigger_traceoff_cmd = {
1080 .name = "traceoff",
1081 .trigger_type = ETT_TRACE_ONOFF,
1082 .flags = EVENT_CMD_FL_POST_TRIGGER,
1083 .func = event_trigger_callback,
1084 .reg = register_trigger,
1085 .unreg = unregister_trigger,
1086 .get_trigger_ops = onoff_get_trigger_ops,
1087 .set_filter = set_trigger_filter,
1088};
1089
1090#ifdef CONFIG_TRACER_SNAPSHOT
1091static void
1092snapshot_trigger(struct event_trigger_data *data,
1093 struct trace_buffer *buffer, void *rec,
1094 struct ring_buffer_event *event)
1095{
1096 struct trace_event_file *file = data->private_data;
1097
1098 if (file)
1099 tracing_snapshot_instance(file->tr);
1100 else
1101 tracing_snapshot();
1102}
1103
1104static void
1105snapshot_count_trigger(struct event_trigger_data *data,
1106 struct trace_buffer *buffer, void *rec,
1107 struct ring_buffer_event *event)
1108{
1109 if (!data->count)
1110 return;
1111
1112 if (data->count != -1)
1113 (data->count)--;
1114
1115 snapshot_trigger(data, buffer, rec, event);
1116}
1117
1118static int
1119register_snapshot_trigger(char *glob, struct event_trigger_ops *ops,
1120 struct event_trigger_data *data,
1121 struct trace_event_file *file)
1122{
1123 if (tracing_alloc_snapshot_instance(file->tr) != 0)
1124 return 0;
1125
1126 return register_trigger(glob, ops, data, file);
1127}
1128
1129static int
1130snapshot_trigger_print(struct seq_file *m, struct event_trigger_ops *ops,
1131 struct event_trigger_data *data)
1132{
1133 return event_trigger_print("snapshot", m, (void *)data->count,
1134 data->filter_str);
1135}
1136
1137static struct event_trigger_ops snapshot_trigger_ops = {
1138 .func = snapshot_trigger,
1139 .print = snapshot_trigger_print,
1140 .init = event_trigger_init,
1141 .free = event_trigger_free,
1142};
1143
1144static struct event_trigger_ops snapshot_count_trigger_ops = {
1145 .func = snapshot_count_trigger,
1146 .print = snapshot_trigger_print,
1147 .init = event_trigger_init,
1148 .free = event_trigger_free,
1149};
1150
1151static struct event_trigger_ops *
1152snapshot_get_trigger_ops(char *cmd, char *param)
1153{
1154 return param ? &snapshot_count_trigger_ops : &snapshot_trigger_ops;
1155}
1156
1157static struct event_command trigger_snapshot_cmd = {
1158 .name = "snapshot",
1159 .trigger_type = ETT_SNAPSHOT,
1160 .func = event_trigger_callback,
1161 .reg = register_snapshot_trigger,
1162 .unreg = unregister_trigger,
1163 .get_trigger_ops = snapshot_get_trigger_ops,
1164 .set_filter = set_trigger_filter,
1165};
1166
1167static __init int register_trigger_snapshot_cmd(void)
1168{
1169 int ret;
1170
1171 ret = register_event_command(&trigger_snapshot_cmd);
1172 WARN_ON(ret < 0);
1173
1174 return ret;
1175}
1176#else
1177static __init int register_trigger_snapshot_cmd(void) { return 0; }
1178#endif
1179
1180#ifdef CONFIG_STACKTRACE
1181#ifdef CONFIG_UNWINDER_ORC
1182
1183
1184
1185
1186# define STACK_SKIP 2
1187#else
1188
1189
1190
1191
1192
1193
1194
1195#define STACK_SKIP 4
1196#endif
1197
1198static void
1199stacktrace_trigger(struct event_trigger_data *data,
1200 struct trace_buffer *buffer, void *rec,
1201 struct ring_buffer_event *event)
1202{
1203 trace_dump_stack(STACK_SKIP);
1204}
1205
1206static void
1207stacktrace_count_trigger(struct event_trigger_data *data,
1208 struct trace_buffer *buffer, void *rec,
1209 struct ring_buffer_event *event)
1210{
1211 if (!data->count)
1212 return;
1213
1214 if (data->count != -1)
1215 (data->count)--;
1216
1217 stacktrace_trigger(data, buffer, rec, event);
1218}
1219
1220static int
1221stacktrace_trigger_print(struct seq_file *m, struct event_trigger_ops *ops,
1222 struct event_trigger_data *data)
1223{
1224 return event_trigger_print("stacktrace", m, (void *)data->count,
1225 data->filter_str);
1226}
1227
1228static struct event_trigger_ops stacktrace_trigger_ops = {
1229 .func = stacktrace_trigger,
1230 .print = stacktrace_trigger_print,
1231 .init = event_trigger_init,
1232 .free = event_trigger_free,
1233};
1234
1235static struct event_trigger_ops stacktrace_count_trigger_ops = {
1236 .func = stacktrace_count_trigger,
1237 .print = stacktrace_trigger_print,
1238 .init = event_trigger_init,
1239 .free = event_trigger_free,
1240};
1241
1242static struct event_trigger_ops *
1243stacktrace_get_trigger_ops(char *cmd, char *param)
1244{
1245 return param ? &stacktrace_count_trigger_ops : &stacktrace_trigger_ops;
1246}
1247
1248static struct event_command trigger_stacktrace_cmd = {
1249 .name = "stacktrace",
1250 .trigger_type = ETT_STACKTRACE,
1251 .flags = EVENT_CMD_FL_POST_TRIGGER,
1252 .func = event_trigger_callback,
1253 .reg = register_trigger,
1254 .unreg = unregister_trigger,
1255 .get_trigger_ops = stacktrace_get_trigger_ops,
1256 .set_filter = set_trigger_filter,
1257};
1258
1259static __init int register_trigger_stacktrace_cmd(void)
1260{
1261 int ret;
1262
1263 ret = register_event_command(&trigger_stacktrace_cmd);
1264 WARN_ON(ret < 0);
1265
1266 return ret;
1267}
1268#else
1269static __init int register_trigger_stacktrace_cmd(void) { return 0; }
1270#endif
1271
1272static __init void unregister_trigger_traceon_traceoff_cmds(void)
1273{
1274 unregister_event_command(&trigger_traceon_cmd);
1275 unregister_event_command(&trigger_traceoff_cmd);
1276}
1277
1278static void
1279event_enable_trigger(struct event_trigger_data *data,
1280 struct trace_buffer *buffer, void *rec,
1281 struct ring_buffer_event *event)
1282{
1283 struct enable_trigger_data *enable_data = data->private_data;
1284
1285 if (enable_data->enable)
1286 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &enable_data->file->flags);
1287 else
1288 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &enable_data->file->flags);
1289}
1290
1291static void
1292event_enable_count_trigger(struct event_trigger_data *data,
1293 struct trace_buffer *buffer, void *rec,
1294 struct ring_buffer_event *event)
1295{
1296 struct enable_trigger_data *enable_data = data->private_data;
1297
1298 if (!data->count)
1299 return;
1300
1301
1302 if (enable_data->enable == !(enable_data->file->flags & EVENT_FILE_FL_SOFT_DISABLED))
1303 return;
1304
1305 if (data->count != -1)
1306 (data->count)--;
1307
1308 event_enable_trigger(data, buffer, rec, event);
1309}
1310
1311int event_enable_trigger_print(struct seq_file *m,
1312 struct event_trigger_ops *ops,
1313 struct event_trigger_data *data)
1314{
1315 struct enable_trigger_data *enable_data = data->private_data;
1316
1317 seq_printf(m, "%s:%s:%s",
1318 enable_data->hist ?
1319 (enable_data->enable ? ENABLE_HIST_STR : DISABLE_HIST_STR) :
1320 (enable_data->enable ? ENABLE_EVENT_STR : DISABLE_EVENT_STR),
1321 enable_data->file->event_call->class->system,
1322 trace_event_name(enable_data->file->event_call));
1323
1324 if (data->count == -1)
1325 seq_puts(m, ":unlimited");
1326 else
1327 seq_printf(m, ":count=%ld", data->count);
1328
1329 if (data->filter_str)
1330 seq_printf(m, " if %s\n", data->filter_str);
1331 else
1332 seq_putc(m, '\n');
1333
1334 return 0;
1335}
1336
1337void event_enable_trigger_free(struct event_trigger_ops *ops,
1338 struct event_trigger_data *data)
1339{
1340 struct enable_trigger_data *enable_data = data->private_data;
1341
1342 if (WARN_ON_ONCE(data->ref <= 0))
1343 return;
1344
1345 data->ref--;
1346 if (!data->ref) {
1347
1348 trace_event_enable_disable(enable_data->file, 0, 1);
1349 trace_event_put_ref(enable_data->file->event_call);
1350 trigger_data_free(data);
1351 kfree(enable_data);
1352 }
1353}
1354
1355static struct event_trigger_ops event_enable_trigger_ops = {
1356 .func = event_enable_trigger,
1357 .print = event_enable_trigger_print,
1358 .init = event_trigger_init,
1359 .free = event_enable_trigger_free,
1360};
1361
1362static struct event_trigger_ops event_enable_count_trigger_ops = {
1363 .func = event_enable_count_trigger,
1364 .print = event_enable_trigger_print,
1365 .init = event_trigger_init,
1366 .free = event_enable_trigger_free,
1367};
1368
1369static struct event_trigger_ops event_disable_trigger_ops = {
1370 .func = event_enable_trigger,
1371 .print = event_enable_trigger_print,
1372 .init = event_trigger_init,
1373 .free = event_enable_trigger_free,
1374};
1375
1376static struct event_trigger_ops event_disable_count_trigger_ops = {
1377 .func = event_enable_count_trigger,
1378 .print = event_enable_trigger_print,
1379 .init = event_trigger_init,
1380 .free = event_enable_trigger_free,
1381};
1382
1383int event_enable_trigger_func(struct event_command *cmd_ops,
1384 struct trace_event_file *file,
1385 char *glob, char *cmd, char *param)
1386{
1387 struct trace_event_file *event_enable_file;
1388 struct enable_trigger_data *enable_data;
1389 struct event_trigger_data *trigger_data;
1390 struct event_trigger_ops *trigger_ops;
1391 struct trace_array *tr = file->tr;
1392 const char *system;
1393 const char *event;
1394 bool hist = false;
1395 char *trigger;
1396 char *number;
1397 bool enable;
1398 int ret;
1399
1400 if (!param)
1401 return -EINVAL;
1402
1403
1404 trigger = strsep(¶m, " \t");
1405 if (!trigger)
1406 return -EINVAL;
1407 if (param) {
1408 param = skip_spaces(param);
1409 if (!*param)
1410 param = NULL;
1411 }
1412
1413 system = strsep(&trigger, ":");
1414 if (!trigger)
1415 return -EINVAL;
1416
1417 event = strsep(&trigger, ":");
1418
1419 ret = -EINVAL;
1420 event_enable_file = find_event_file(tr, system, event);
1421 if (!event_enable_file)
1422 goto out;
1423
1424#ifdef CONFIG_HIST_TRIGGERS
1425 hist = ((strcmp(cmd, ENABLE_HIST_STR) == 0) ||
1426 (strcmp(cmd, DISABLE_HIST_STR) == 0));
1427
1428 enable = ((strcmp(cmd, ENABLE_EVENT_STR) == 0) ||
1429 (strcmp(cmd, ENABLE_HIST_STR) == 0));
1430#else
1431 enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
1432#endif
1433 trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);
1434
1435 ret = -ENOMEM;
1436 trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
1437 if (!trigger_data)
1438 goto out;
1439
1440 enable_data = kzalloc(sizeof(*enable_data), GFP_KERNEL);
1441 if (!enable_data) {
1442 kfree(trigger_data);
1443 goto out;
1444 }
1445
1446 trigger_data->count = -1;
1447 trigger_data->ops = trigger_ops;
1448 trigger_data->cmd_ops = cmd_ops;
1449 INIT_LIST_HEAD(&trigger_data->list);
1450 RCU_INIT_POINTER(trigger_data->filter, NULL);
1451
1452 enable_data->hist = hist;
1453 enable_data->enable = enable;
1454 enable_data->file = event_enable_file;
1455 trigger_data->private_data = enable_data;
1456
1457 if (glob[0] == '!') {
1458 cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file);
1459 kfree(trigger_data);
1460 kfree(enable_data);
1461 ret = 0;
1462 goto out;
1463 }
1464
1465
1466 event_trigger_init(trigger_ops, trigger_data);
1467
1468 if (trigger) {
1469 number = strsep(&trigger, ":");
1470
1471 ret = -EINVAL;
1472 if (!strlen(number))
1473 goto out_free;
1474
1475
1476
1477
1478
1479 ret = kstrtoul(number, 0, &trigger_data->count);
1480 if (ret)
1481 goto out_free;
1482 }
1483
1484 if (!param)
1485 goto out_reg;
1486
1487 if (!cmd_ops->set_filter)
1488 goto out_reg;
1489
1490 ret = cmd_ops->set_filter(param, trigger_data, file);
1491 if (ret < 0)
1492 goto out_free;
1493
1494 out_reg:
1495
1496 ret = trace_event_try_get_ref(event_enable_file->event_call);
1497 if (!ret) {
1498 ret = -EBUSY;
1499 goto out_free;
1500 }
1501
1502 ret = trace_event_enable_disable(event_enable_file, 1, 1);
1503 if (ret < 0)
1504 goto out_put;
1505 ret = cmd_ops->reg(glob, trigger_ops, trigger_data, file);
1506
1507
1508
1509
1510
1511 if (!ret) {
1512 ret = -ENOENT;
1513 goto out_disable;
1514 } else if (ret < 0)
1515 goto out_disable;
1516
1517 ret = 0;
1518 event_trigger_free(trigger_ops, trigger_data);
1519 out:
1520 return ret;
1521
1522 out_disable:
1523 trace_event_enable_disable(event_enable_file, 0, 1);
1524 out_put:
1525 trace_event_put_ref(event_enable_file->event_call);
1526 out_free:
1527 if (cmd_ops->set_filter)
1528 cmd_ops->set_filter(NULL, trigger_data, NULL);
1529 event_trigger_free(trigger_ops, trigger_data);
1530 kfree(enable_data);
1531 goto out;
1532}
1533
1534int event_enable_register_trigger(char *glob,
1535 struct event_trigger_ops *ops,
1536 struct event_trigger_data *data,
1537 struct trace_event_file *file)
1538{
1539 struct enable_trigger_data *enable_data = data->private_data;
1540 struct enable_trigger_data *test_enable_data;
1541 struct event_trigger_data *test;
1542 int ret = 0;
1543
1544 lockdep_assert_held(&event_mutex);
1545
1546 list_for_each_entry(test, &file->triggers, list) {
1547 test_enable_data = test->private_data;
1548 if (test_enable_data &&
1549 (test->cmd_ops->trigger_type ==
1550 data->cmd_ops->trigger_type) &&
1551 (test_enable_data->file == enable_data->file)) {
1552 ret = -EEXIST;
1553 goto out;
1554 }
1555 }
1556
1557 if (data->ops->init) {
1558 ret = data->ops->init(data->ops, data);
1559 if (ret < 0)
1560 goto out;
1561 }
1562
1563 list_add_rcu(&data->list, &file->triggers);
1564 ret++;
1565
1566 update_cond_flag(file);
1567 if (trace_event_trigger_enable_disable(file, 1) < 0) {
1568 list_del_rcu(&data->list);
1569 update_cond_flag(file);
1570 ret--;
1571 }
1572out:
1573 return ret;
1574}
1575
1576void event_enable_unregister_trigger(char *glob,
1577 struct event_trigger_ops *ops,
1578 struct event_trigger_data *test,
1579 struct trace_event_file *file)
1580{
1581 struct enable_trigger_data *test_enable_data = test->private_data;
1582 struct enable_trigger_data *enable_data;
1583 struct event_trigger_data *data;
1584 bool unregistered = false;
1585
1586 lockdep_assert_held(&event_mutex);
1587
1588 list_for_each_entry(data, &file->triggers, list) {
1589 enable_data = data->private_data;
1590 if (enable_data &&
1591 (data->cmd_ops->trigger_type ==
1592 test->cmd_ops->trigger_type) &&
1593 (enable_data->file == test_enable_data->file)) {
1594 unregistered = true;
1595 list_del_rcu(&data->list);
1596 trace_event_trigger_enable_disable(file, 0);
1597 update_cond_flag(file);
1598 break;
1599 }
1600 }
1601
1602 if (unregistered && data->ops->free)
1603 data->ops->free(data->ops, data);
1604}
1605
1606static struct event_trigger_ops *
1607event_enable_get_trigger_ops(char *cmd, char *param)
1608{
1609 struct event_trigger_ops *ops;
1610 bool enable;
1611
1612#ifdef CONFIG_HIST_TRIGGERS
1613 enable = ((strcmp(cmd, ENABLE_EVENT_STR) == 0) ||
1614 (strcmp(cmd, ENABLE_HIST_STR) == 0));
1615#else
1616 enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
1617#endif
1618 if (enable)
1619 ops = param ? &event_enable_count_trigger_ops :
1620 &event_enable_trigger_ops;
1621 else
1622 ops = param ? &event_disable_count_trigger_ops :
1623 &event_disable_trigger_ops;
1624
1625 return ops;
1626}
1627
1628static struct event_command trigger_enable_cmd = {
1629 .name = ENABLE_EVENT_STR,
1630 .trigger_type = ETT_EVENT_ENABLE,
1631 .func = event_enable_trigger_func,
1632 .reg = event_enable_register_trigger,
1633 .unreg = event_enable_unregister_trigger,
1634 .get_trigger_ops = event_enable_get_trigger_ops,
1635 .set_filter = set_trigger_filter,
1636};
1637
1638static struct event_command trigger_disable_cmd = {
1639 .name = DISABLE_EVENT_STR,
1640 .trigger_type = ETT_EVENT_ENABLE,
1641 .func = event_enable_trigger_func,
1642 .reg = event_enable_register_trigger,
1643 .unreg = event_enable_unregister_trigger,
1644 .get_trigger_ops = event_enable_get_trigger_ops,
1645 .set_filter = set_trigger_filter,
1646};
1647
1648static __init void unregister_trigger_enable_disable_cmds(void)
1649{
1650 unregister_event_command(&trigger_enable_cmd);
1651 unregister_event_command(&trigger_disable_cmd);
1652}
1653
1654static __init int register_trigger_enable_disable_cmds(void)
1655{
1656 int ret;
1657
1658 ret = register_event_command(&trigger_enable_cmd);
1659 if (WARN_ON(ret < 0))
1660 return ret;
1661 ret = register_event_command(&trigger_disable_cmd);
1662 if (WARN_ON(ret < 0))
1663 unregister_trigger_enable_disable_cmds();
1664
1665 return ret;
1666}
1667
1668static __init int register_trigger_traceon_traceoff_cmds(void)
1669{
1670 int ret;
1671
1672 ret = register_event_command(&trigger_traceon_cmd);
1673 if (WARN_ON(ret < 0))
1674 return ret;
1675 ret = register_event_command(&trigger_traceoff_cmd);
1676 if (WARN_ON(ret < 0))
1677 unregister_trigger_traceon_traceoff_cmds();
1678
1679 return ret;
1680}
1681
1682__init int register_trigger_cmds(void)
1683{
1684 register_trigger_traceon_traceoff_cmds();
1685 register_trigger_snapshot_cmd();
1686 register_trigger_stacktrace_cmd();
1687 register_trigger_enable_disable_cmds();
1688 register_trigger_hist_enable_disable_cmds();
1689 register_trigger_hist_cmd();
1690
1691 return 0;
1692}
1693