?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'chrome-platform-for-linus-4.13' of git://git.kernel.org/pub/scm/linux...
[linux/fpc-iii.git] / kernel / trace / trace_events_hist.c
blob1c21d0e2a145a6e180116fc1fd0705ae7e3fdb17
1 /*
2 * trace_events_hist - trace event hist 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 * Copyright (C) 2015 Tom Zanussi <tom.zanussi@linux.intel.com>
15 */
16
17 #include <linux/module.h>
18 #include <linux/kallsyms.h>
19 #include <linux/mutex.h>
20 #include <linux/slab.h>
21 #include <linux/stacktrace.h>
22 #include <linux/rculist.h>
23
24 #include "tracing_map.h"
25 #include "trace.h"
26
27 struct hist_field;
28
29 typedef u64 (*hist_field_fn_t) (struct hist_field *field, void *event);
30
31 struct hist_field {
32 struct ftrace_event_field *field;
33 unsigned long flags;
34 hist_field_fn_t fn;
35 unsigned int size;
36 unsigned int offset;
37 };
38
39 static u64 hist_field_none(struct hist_field *field, void *event)
40 {
41 return 0;
42 }
43
44 static u64 hist_field_counter(struct hist_field *field, void *event)
45 {
46 return 1;
47 }
48
49 static u64 hist_field_string(struct hist_field *hist_field, void *event)
50 {
51 char *addr = (char *)(event + hist_field->field->offset);
52
53 return (u64)(unsigned long)addr;
54 }
55
56 static u64 hist_field_dynstring(struct hist_field *hist_field, void *event)
57 {
58 u32 str_item = *(u32 *)(event + hist_field->field->offset);
59 int str_loc = str_item & 0xffff;
60 char *addr = (char *)(event + str_loc);
61
62 return (u64)(unsigned long)addr;
63 }
64
65 static u64 hist_field_pstring(struct hist_field *hist_field, void *event)
66 {
67 char **addr = (char **)(event + hist_field->field->offset);
68
69 return (u64)(unsigned long)*addr;
70 }
71
72 static u64 hist_field_log2(struct hist_field *hist_field, void *event)
73 {
74 u64 val = *(u64 *)(event + hist_field->field->offset);
75
76 return (u64) ilog2(roundup_pow_of_two(val));
77 }
78
79 #define DEFINE_HIST_FIELD_FN(type) \
80 static u64 hist_field_##type(struct hist_field *hist_field, void *event)\
81 { \
82 type *addr = (type *)(event + hist_field->field->offset); \
83 \
84 return (u64)(unsigned long)*addr; \
85 }
86
87 DEFINE_HIST_FIELD_FN(s64);
88 DEFINE_HIST_FIELD_FN(u64);
89 DEFINE_HIST_FIELD_FN(s32);
90 DEFINE_HIST_FIELD_FN(u32);
91 DEFINE_HIST_FIELD_FN(s16);
92 DEFINE_HIST_FIELD_FN(u16);
93 DEFINE_HIST_FIELD_FN(s8);
94 DEFINE_HIST_FIELD_FN(u8);
95
96 #define for_each_hist_field(i, hist_data) \
97 for ((i) = 0; (i) < (hist_data)->n_fields; (i)++)
98
99 #define for_each_hist_val_field(i, hist_data) \
100 for ((i) = 0; (i) < (hist_data)->n_vals; (i)++)
101
102 #define for_each_hist_key_field(i, hist_data) \
103 for ((i) = (hist_data)->n_vals; (i) < (hist_data)->n_fields; (i)++)
104
105 #define HIST_STACKTRACE_DEPTH 16
106 #define HIST_STACKTRACE_SIZE (HIST_STACKTRACE_DEPTH * sizeof(unsigned long))
107 #define HIST_STACKTRACE_SKIP 5
108
109 #define HITCOUNT_IDX 0
110 #define HIST_KEY_SIZE_MAX (MAX_FILTER_STR_VAL + HIST_STACKTRACE_SIZE)
111
112 enum hist_field_flags {
113 HIST_FIELD_FL_HITCOUNT = 1,
114 HIST_FIELD_FL_KEY = 2,
115 HIST_FIELD_FL_STRING = 4,
116 HIST_FIELD_FL_HEX = 8,
117 HIST_FIELD_FL_SYM = 16,
118 HIST_FIELD_FL_SYM_OFFSET = 32,
119 HIST_FIELD_FL_EXECNAME = 64,
120 HIST_FIELD_FL_SYSCALL = 128,
121 HIST_FIELD_FL_STACKTRACE = 256,
122 HIST_FIELD_FL_LOG2 = 512,
123 };
124
125 struct hist_trigger_attrs {
126 char *keys_str;
127 char *vals_str;
128 char *sort_key_str;
129 char *name;
130 bool pause;
131 bool cont;
132 bool clear;
133 unsigned int map_bits;
134 };
135
136 struct hist_trigger_data {
137 struct hist_field *fields[TRACING_MAP_FIELDS_MAX];
138 unsigned int n_vals;
139 unsigned int n_keys;
140 unsigned int n_fields;
141 unsigned int key_size;
142 struct tracing_map_sort_key sort_keys[TRACING_MAP_SORT_KEYS_MAX];
143 unsigned int n_sort_keys;
144 struct trace_event_file *event_file;
145 struct hist_trigger_attrs *attrs;
146 struct tracing_map *map;
147 };
148
149 static hist_field_fn_t select_value_fn(int field_size, int field_is_signed)
150 {
151 hist_field_fn_t fn = NULL;
152
153 switch (field_size) {
154 case 8:
155 if (field_is_signed)
156 fn = hist_field_s64;
157 else
158 fn = hist_field_u64;
159 break;
160 case 4:
161 if (field_is_signed)
162 fn = hist_field_s32;
163 else
164 fn = hist_field_u32;
165 break;
166 case 2:
167 if (field_is_signed)
168 fn = hist_field_s16;
169 else
170 fn = hist_field_u16;
171 break;
172 case 1:
173 if (field_is_signed)
174 fn = hist_field_s8;
175 else
176 fn = hist_field_u8;
177 break;
178 }
179
180 return fn;
181 }
182
183 static int parse_map_size(char *str)
184 {
185 unsigned long size, map_bits;
186 int ret;
187
188 strsep(&str, "=");
189 if (!str) {
190 ret = -EINVAL;
191 goto out;
192 }
193
194 ret = kstrtoul(str, 0, &size);
195 if (ret)
196 goto out;
197
198 map_bits = ilog2(roundup_pow_of_two(size));
199 if (map_bits < TRACING_MAP_BITS_MIN ||
200 map_bits > TRACING_MAP_BITS_MAX)
201 ret = -EINVAL;
202 else
203 ret = map_bits;
204 out:
205 return ret;
206 }
207
208 static void destroy_hist_trigger_attrs(struct hist_trigger_attrs *attrs)
209 {
210 if (!attrs)
211 return;
212
213 kfree(attrs->name);
214 kfree(attrs->sort_key_str);
215 kfree(attrs->keys_str);
216 kfree(attrs->vals_str);
217 kfree(attrs);
218 }
219
220 static struct hist_trigger_attrs *parse_hist_trigger_attrs(char *trigger_str)
221 {
222 struct hist_trigger_attrs *attrs;
223 int ret = 0;
224
225 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
226 if (!attrs)
227 return ERR_PTR(-ENOMEM);
228
229 while (trigger_str) {
230 char *str = strsep(&trigger_str, ":");
231
232 if ((strncmp(str, "key=", strlen("key=")) == 0) ||
233 (strncmp(str, "keys=", strlen("keys=")) == 0))
234 attrs->keys_str = kstrdup(str, GFP_KERNEL);
235 else if ((strncmp(str, "val=", strlen("val=")) == 0) ||
236 (strncmp(str, "vals=", strlen("vals=")) == 0) ||
237 (strncmp(str, "values=", strlen("values=")) == 0))
238 attrs->vals_str = kstrdup(str, GFP_KERNEL);
239 else if (strncmp(str, "sort=", strlen("sort=")) == 0)
240 attrs->sort_key_str = kstrdup(str, GFP_KERNEL);
241 else if (strncmp(str, "name=", strlen("name=")) == 0)
242 attrs->name = kstrdup(str, GFP_KERNEL);
243 else if (strcmp(str, "pause") == 0)
244 attrs->pause = true;
245 else if ((strcmp(str, "cont") == 0) ||
246 (strcmp(str, "continue") == 0))
247 attrs->cont = true;
248 else if (strcmp(str, "clear") == 0)
249 attrs->clear = true;
250 else if (strncmp(str, "size=", strlen("size=")) == 0) {
251 int map_bits = parse_map_size(str);
252
253 if (map_bits < 0) {
254 ret = map_bits;
255 goto free;
256 }
257 attrs->map_bits = map_bits;
258 } else {
259 ret = -EINVAL;
260 goto free;
261 }
262 }
263
264 if (!attrs->keys_str) {
265 ret = -EINVAL;
266 goto free;
267 }
268
269 return attrs;
270 free:
271 destroy_hist_trigger_attrs(attrs);
272
273 return ERR_PTR(ret);
274 }
275
276 static inline void save_comm(char *comm, struct task_struct *task)
277 {
278 if (!task->pid) {
279 strcpy(comm, "<idle>");
280 return;
281 }
282
283 if (WARN_ON_ONCE(task->pid < 0)) {
284 strcpy(comm, "<XXX>");
285 return;
286 }
287
288 memcpy(comm, task->comm, TASK_COMM_LEN);
289 }
290
291 static void hist_trigger_elt_comm_free(struct tracing_map_elt *elt)
292 {
293 kfree((char *)elt->private_data);
294 }
295
296 static int hist_trigger_elt_comm_alloc(struct tracing_map_elt *elt)
297 {
298 struct hist_trigger_data *hist_data = elt->map->private_data;
299 struct hist_field *key_field;
300 unsigned int i;
301
302 for_each_hist_key_field(i, hist_data) {
303 key_field = hist_data->fields[i];
304
305 if (key_field->flags & HIST_FIELD_FL_EXECNAME) {
306 unsigned int size = TASK_COMM_LEN + 1;
307
308 elt->private_data = kzalloc(size, GFP_KERNEL);
309 if (!elt->private_data)
310 return -ENOMEM;
311 break;
312 }
313 }
314
315 return 0;
316 }
317
318 static void hist_trigger_elt_comm_copy(struct tracing_map_elt *to,
319 struct tracing_map_elt *from)
320 {
321 char *comm_from = from->private_data;
322 char *comm_to = to->private_data;
323
324 if (comm_from)
325 memcpy(comm_to, comm_from, TASK_COMM_LEN + 1);
326 }
327
328 static void hist_trigger_elt_comm_init(struct tracing_map_elt *elt)
329 {
330 char *comm = elt->private_data;
331
332 if (comm)
333 save_comm(comm, current);
334 }
335
336 static const struct tracing_map_ops hist_trigger_elt_comm_ops = {
337 .elt_alloc = hist_trigger_elt_comm_alloc,
338 .elt_copy = hist_trigger_elt_comm_copy,
339 .elt_free = hist_trigger_elt_comm_free,
340 .elt_init = hist_trigger_elt_comm_init,
341 };
342
343 static void destroy_hist_field(struct hist_field *hist_field)
344 {
345 kfree(hist_field);
346 }
347
348 static struct hist_field *create_hist_field(struct ftrace_event_field *field,
349 unsigned long flags)
350 {
351 struct hist_field *hist_field;
352
353 if (field && is_function_field(field))
354 return NULL;
355
356 hist_field = kzalloc(sizeof(struct hist_field), GFP_KERNEL);
357 if (!hist_field)
358 return NULL;
359
360 if (flags & HIST_FIELD_FL_HITCOUNT) {
361 hist_field->fn = hist_field_counter;
362 goto out;
363 }
364
365 if (flags & HIST_FIELD_FL_STACKTRACE) {
366 hist_field->fn = hist_field_none;
367 goto out;
368 }
369
370 if (flags & HIST_FIELD_FL_LOG2) {
371 hist_field->fn = hist_field_log2;
372 goto out;
373 }
374
375 if (WARN_ON_ONCE(!field))
376 goto out;
377
378 if (is_string_field(field)) {
379 flags |= HIST_FIELD_FL_STRING;
380
381 if (field->filter_type == FILTER_STATIC_STRING)
382 hist_field->fn = hist_field_string;
383 else if (field->filter_type == FILTER_DYN_STRING)
384 hist_field->fn = hist_field_dynstring;
385 else
386 hist_field->fn = hist_field_pstring;
387 } else {
388 hist_field->fn = select_value_fn(field->size,
389 field->is_signed);
390 if (!hist_field->fn) {
391 destroy_hist_field(hist_field);
392 return NULL;
393 }
394 }
395 out:
396 hist_field->field = field;
397 hist_field->flags = flags;
398
399 return hist_field;
400 }
401
402 static void destroy_hist_fields(struct hist_trigger_data *hist_data)
403 {
404 unsigned int i;
405
406 for (i = 0; i < TRACING_MAP_FIELDS_MAX; i++) {
407 if (hist_data->fields[i]) {
408 destroy_hist_field(hist_data->fields[i]);
409 hist_data->fields[i] = NULL;
410 }
411 }
412 }
413
414 static int create_hitcount_val(struct hist_trigger_data *hist_data)
415 {
416 hist_data->fields[HITCOUNT_IDX] =
417 create_hist_field(NULL, HIST_FIELD_FL_HITCOUNT);
418 if (!hist_data->fields[HITCOUNT_IDX])
419 return -ENOMEM;
420
421 hist_data->n_vals++;
422
423 if (WARN_ON(hist_data->n_vals > TRACING_MAP_VALS_MAX))
424 return -EINVAL;
425
426 return 0;
427 }
428
429 static int create_val_field(struct hist_trigger_data *hist_data,
430 unsigned int val_idx,
431 struct trace_event_file *file,
432 char *field_str)
433 {
434 struct ftrace_event_field *field = NULL;
435 unsigned long flags = 0;
436 char *field_name;
437 int ret = 0;
438
439 if (WARN_ON(val_idx >= TRACING_MAP_VALS_MAX))
440 return -EINVAL;
441
442 field_name = strsep(&field_str, ".");
443 if (field_str) {
444 if (strcmp(field_str, "hex") == 0)
445 flags |= HIST_FIELD_FL_HEX;
446 else {
447 ret = -EINVAL;
448 goto out;
449 }
450 }
451
452 field = trace_find_event_field(file->event_call, field_name);
453 if (!field) {
454 ret = -EINVAL;
455 goto out;
456 }
457
458 hist_data->fields[val_idx] = create_hist_field(field, flags);
459 if (!hist_data->fields[val_idx]) {
460 ret = -ENOMEM;
461 goto out;
462 }
463
464 ++hist_data->n_vals;
465
466 if (WARN_ON(hist_data->n_vals > TRACING_MAP_VALS_MAX))
467 ret = -EINVAL;
468 out:
469 return ret;
470 }
471
472 static int create_val_fields(struct hist_trigger_data *hist_data,
473 struct trace_event_file *file)
474 {
475 char *fields_str, *field_str;
476 unsigned int i, j;
477 int ret;
478
479 ret = create_hitcount_val(hist_data);
480 if (ret)
481 goto out;
482
483 fields_str = hist_data->attrs->vals_str;
484 if (!fields_str)
485 goto out;
486
487 strsep(&fields_str, "=");
488 if (!fields_str)
489 goto out;
490
491 for (i = 0, j = 1; i < TRACING_MAP_VALS_MAX &&
492 j < TRACING_MAP_VALS_MAX; i++) {
493 field_str = strsep(&fields_str, ",");
494 if (!field_str)
495 break;
496 if (strcmp(field_str, "hitcount") == 0)
497 continue;
498 ret = create_val_field(hist_data, j++, file, field_str);
499 if (ret)
500 goto out;
501 }
502 if (fields_str && (strcmp(fields_str, "hitcount") != 0))
503 ret = -EINVAL;
504 out:
505 return ret;
506 }
507
508 static int create_key_field(struct hist_trigger_data *hist_data,
509 unsigned int key_idx,
510 unsigned int key_offset,
511 struct trace_event_file *file,
512 char *field_str)
513 {
514 struct ftrace_event_field *field = NULL;
515 unsigned long flags = 0;
516 unsigned int key_size;
517 int ret = 0;
518
519 if (WARN_ON(key_idx >= TRACING_MAP_FIELDS_MAX))
520 return -EINVAL;
521
522 flags |= HIST_FIELD_FL_KEY;
523
524 if (strcmp(field_str, "stacktrace") == 0) {
525 flags |= HIST_FIELD_FL_STACKTRACE;
526 key_size = sizeof(unsigned long) * HIST_STACKTRACE_DEPTH;
527 } else {
528 char *field_name = strsep(&field_str, ".");
529
530 if (field_str) {
531 if (strcmp(field_str, "hex") == 0)
532 flags |= HIST_FIELD_FL_HEX;
533 else if (strcmp(field_str, "sym") == 0)
534 flags |= HIST_FIELD_FL_SYM;
535 else if (strcmp(field_str, "sym-offset") == 0)
536 flags |= HIST_FIELD_FL_SYM_OFFSET;
537 else if ((strcmp(field_str, "execname") == 0) &&
538 (strcmp(field_name, "common_pid") == 0))
539 flags |= HIST_FIELD_FL_EXECNAME;
540 else if (strcmp(field_str, "syscall") == 0)
541 flags |= HIST_FIELD_FL_SYSCALL;
542 else if (strcmp(field_str, "log2") == 0)
543 flags |= HIST_FIELD_FL_LOG2;
544 else {
545 ret = -EINVAL;
546 goto out;
547 }
548 }
549
550 field = trace_find_event_field(file->event_call, field_name);
551 if (!field) {
552 ret = -EINVAL;
553 goto out;
554 }
555
556 if (is_string_field(field))
557 key_size = MAX_FILTER_STR_VAL;
558 else
559 key_size = field->size;
560 }
561
562 hist_data->fields[key_idx] = create_hist_field(field, flags);
563 if (!hist_data->fields[key_idx]) {
564 ret = -ENOMEM;
565 goto out;
566 }
567
568 key_size = ALIGN(key_size, sizeof(u64));
569 hist_data->fields[key_idx]->size = key_size;
570 hist_data->fields[key_idx]->offset = key_offset;
571 hist_data->key_size += key_size;
572 if (hist_data->key_size > HIST_KEY_SIZE_MAX) {
573 ret = -EINVAL;
574 goto out;
575 }
576
577 hist_data->n_keys++;
578
579 if (WARN_ON(hist_data->n_keys > TRACING_MAP_KEYS_MAX))
580 return -EINVAL;
581
582 ret = key_size;
583 out:
584 return ret;
585 }
586
587 static int create_key_fields(struct hist_trigger_data *hist_data,
588 struct trace_event_file *file)
589 {
590 unsigned int i, key_offset = 0, n_vals = hist_data->n_vals;
591 char *fields_str, *field_str;
592 int ret = -EINVAL;
593
594 fields_str = hist_data->attrs->keys_str;
595 if (!fields_str)
596 goto out;
597
598 strsep(&fields_str, "=");
599 if (!fields_str)
600 goto out;
601
602 for (i = n_vals; i < n_vals + TRACING_MAP_KEYS_MAX; i++) {
603 field_str = strsep(&fields_str, ",");
604 if (!field_str)
605 break;
606 ret = create_key_field(hist_data, i, key_offset,
607 file, field_str);
608 if (ret < 0)
609 goto out;
610 key_offset += ret;
611 }
612 if (fields_str) {
613 ret = -EINVAL;
614 goto out;
615 }
616 ret = 0;
617 out:
618 return ret;
619 }
620
621 static int create_hist_fields(struct hist_trigger_data *hist_data,
622 struct trace_event_file *file)
623 {
624 int ret;
625
626 ret = create_val_fields(hist_data, file);
627 if (ret)
628 goto out;
629
630 ret = create_key_fields(hist_data, file);
631 if (ret)
632 goto out;
633
634 hist_data->n_fields = hist_data->n_vals + hist_data->n_keys;
635 out:
636 return ret;
637 }
638
639 static int is_descending(const char *str)
640 {
641 if (!str)
642 return 0;
643
644 if (strcmp(str, "descending") == 0)
645 return 1;
646
647 if (strcmp(str, "ascending") == 0)
648 return 0;
649
650 return -EINVAL;
651 }
652
653 static int create_sort_keys(struct hist_trigger_data *hist_data)
654 {
655 char *fields_str = hist_data->attrs->sort_key_str;
656 struct ftrace_event_field *field = NULL;
657 struct tracing_map_sort_key *sort_key;
658 int descending, ret = 0;
659 unsigned int i, j;
660
661 hist_data->n_sort_keys = 1; /* we always have at least one, hitcount */
662
663 if (!fields_str)
664 goto out;
665
666 strsep(&fields_str, "=");
667 if (!fields_str) {
668 ret = -EINVAL;
669 goto out;
670 }
671
672 for (i = 0; i < TRACING_MAP_SORT_KEYS_MAX; i++) {
673 char *field_str, *field_name;
674
675 sort_key = &hist_data->sort_keys[i];
676
677 field_str = strsep(&fields_str, ",");
678 if (!field_str) {
679 if (i == 0)
680 ret = -EINVAL;
681 break;
682 }
683
684 if ((i == TRACING_MAP_SORT_KEYS_MAX - 1) && fields_str) {
685 ret = -EINVAL;
686 break;
687 }
688
689 field_name = strsep(&field_str, ".");
690 if (!field_name) {
691 ret = -EINVAL;
692 break;
693 }
694
695 if (strcmp(field_name, "hitcount") == 0) {
696 descending = is_descending(field_str);
697 if (descending < 0) {
698 ret = descending;
699 break;
700 }
701 sort_key->descending = descending;
702 continue;
703 }
704
705 for (j = 1; j < hist_data->n_fields; j++) {
706 field = hist_data->fields[j]->field;
707 if (field && (strcmp(field_name, field->name) == 0)) {
708 sort_key->field_idx = j;
709 descending = is_descending(field_str);
710 if (descending < 0) {
711 ret = descending;
712 goto out;
713 }
714 sort_key->descending = descending;
715 break;
716 }
717 }
718 if (j == hist_data->n_fields) {
719 ret = -EINVAL;
720 break;
721 }
722 }
723 hist_data->n_sort_keys = i;
724 out:
725 return ret;
726 }
727
728 static void destroy_hist_data(struct hist_trigger_data *hist_data)
729 {
730 destroy_hist_trigger_attrs(hist_data->attrs);
731 destroy_hist_fields(hist_data);
732 tracing_map_destroy(hist_data->map);
733 kfree(hist_data);
734 }
735
736 static int create_tracing_map_fields(struct hist_trigger_data *hist_data)
737 {
738 struct tracing_map *map = hist_data->map;
739 struct ftrace_event_field *field;
740 struct hist_field *hist_field;
741 int i, idx;
742
743 for_each_hist_field(i, hist_data) {
744 hist_field = hist_data->fields[i];
745 if (hist_field->flags & HIST_FIELD_FL_KEY) {
746 tracing_map_cmp_fn_t cmp_fn;
747
748 field = hist_field->field;
749
750 if (hist_field->flags & HIST_FIELD_FL_STACKTRACE)
751 cmp_fn = tracing_map_cmp_none;
752 else if (is_string_field(field))
753 cmp_fn = tracing_map_cmp_string;
754 else
755 cmp_fn = tracing_map_cmp_num(field->size,
756 field->is_signed);
757 idx = tracing_map_add_key_field(map,
758 hist_field->offset,
759 cmp_fn);
760
761 } else
762 idx = tracing_map_add_sum_field(map);
763
764 if (idx < 0)
765 return idx;
766 }
767
768 return 0;
769 }
770
771 static bool need_tracing_map_ops(struct hist_trigger_data *hist_data)
772 {
773 struct hist_field *key_field;
774 unsigned int i;
775
776 for_each_hist_key_field(i, hist_data) {
777 key_field = hist_data->fields[i];
778
779 if (key_field->flags & HIST_FIELD_FL_EXECNAME)
780 return true;
781 }
782
783 return false;
784 }
785
786 static struct hist_trigger_data *
787 create_hist_data(unsigned int map_bits,
788 struct hist_trigger_attrs *attrs,
789 struct trace_event_file *file)
790 {
791 const struct tracing_map_ops *map_ops = NULL;
792 struct hist_trigger_data *hist_data;
793 int ret = 0;
794
795 hist_data = kzalloc(sizeof(*hist_data), GFP_KERNEL);
796 if (!hist_data)
797 return ERR_PTR(-ENOMEM);
798
799 hist_data->attrs = attrs;
800
801 ret = create_hist_fields(hist_data, file);
802 if (ret)
803 goto free;
804
805 ret = create_sort_keys(hist_data);
806 if (ret)
807 goto free;
808
809 if (need_tracing_map_ops(hist_data))
810 map_ops = &hist_trigger_elt_comm_ops;
811
812 hist_data->map = tracing_map_create(map_bits, hist_data->key_size,
813 map_ops, hist_data);
814 if (IS_ERR(hist_data->map)) {
815 ret = PTR_ERR(hist_data->map);
816 hist_data->map = NULL;
817 goto free;
818 }
819
820 ret = create_tracing_map_fields(hist_data);
821 if (ret)
822 goto free;
823
824 ret = tracing_map_init(hist_data->map);
825 if (ret)
826 goto free;
827
828 hist_data->event_file = file;
829 out:
830 return hist_data;
831 free:
832 hist_data->attrs = NULL;
833
834 destroy_hist_data(hist_data);
835
836 hist_data = ERR_PTR(ret);
837
838 goto out;
839 }
840
841 static void hist_trigger_elt_update(struct hist_trigger_data *hist_data,
842 struct tracing_map_elt *elt,
843 void *rec)
844 {
845 struct hist_field *hist_field;
846 unsigned int i;
847 u64 hist_val;
848
849 for_each_hist_val_field(i, hist_data) {
850 hist_field = hist_data->fields[i];
851 hist_val = hist_field->fn(hist_field, rec);
852 tracing_map_update_sum(elt, i, hist_val);
853 }
854 }
855
856 static inline void add_to_key(char *compound_key, void *key,
857 struct hist_field *key_field, void *rec)
858 {
859 size_t size = key_field->size;
860
861 if (key_field->flags & HIST_FIELD_FL_STRING) {
862 struct ftrace_event_field *field;
863
864 field = key_field->field;
865 if (field->filter_type == FILTER_DYN_STRING)
866 size = *(u32 *)(rec + field->offset) >> 16;
867 else if (field->filter_type == FILTER_PTR_STRING)
868 size = strlen(key);
869 else if (field->filter_type == FILTER_STATIC_STRING)
870 size = field->size;
871
872 /* ensure NULL-termination */
873 if (size > key_field->size - 1)
874 size = key_field->size - 1;
875 }
876
877 memcpy(compound_key + key_field->offset, key, size);
878 }
879
880 static void event_hist_trigger(struct event_trigger_data *data, void *rec)
881 {
882 struct hist_trigger_data *hist_data = data->private_data;
883 bool use_compound_key = (hist_data->n_keys > 1);
884 unsigned long entries[HIST_STACKTRACE_DEPTH];
885 char compound_key[HIST_KEY_SIZE_MAX];
886 struct stack_trace stacktrace;
887 struct hist_field *key_field;
888 struct tracing_map_elt *elt;
889 u64 field_contents;
890 void *key = NULL;
891 unsigned int i;
892
893 memset(compound_key, 0, hist_data->key_size);
894
895 for_each_hist_key_field(i, hist_data) {
896 key_field = hist_data->fields[i];
897
898 if (key_field->flags & HIST_FIELD_FL_STACKTRACE) {
899 stacktrace.max_entries = HIST_STACKTRACE_DEPTH;
900 stacktrace.entries = entries;
901 stacktrace.nr_entries = 0;
902 stacktrace.skip = HIST_STACKTRACE_SKIP;
903
904 memset(stacktrace.entries, 0, HIST_STACKTRACE_SIZE);
905 save_stack_trace(&stacktrace);
906
907 key = entries;
908 } else {
909 field_contents = key_field->fn(key_field, rec);
910 if (key_field->flags & HIST_FIELD_FL_STRING) {
911 key = (void *)(unsigned long)field_contents;
912 use_compound_key = true;
913 } else
914 key = (void *)&field_contents;
915 }
916
917 if (use_compound_key)
918 add_to_key(compound_key, key, key_field, rec);
919 }
920
921 if (use_compound_key)
922 key = compound_key;
923
924 elt = tracing_map_insert(hist_data->map, key);
925 if (elt)
926 hist_trigger_elt_update(hist_data, elt, rec);
927 }
928
929 static void hist_trigger_stacktrace_print(struct seq_file *m,
930 unsigned long *stacktrace_entries,
931 unsigned int max_entries)
932 {
933 char str[KSYM_SYMBOL_LEN];
934 unsigned int spaces = 8;
935 unsigned int i;
936
937 for (i = 0; i < max_entries; i++) {
938 if (stacktrace_entries[i] == ULONG_MAX)
939 return;
940
941 seq_printf(m, "%*c", 1 + spaces, ' ');
942 sprint_symbol(str, stacktrace_entries[i]);
943 seq_printf(m, "%s\n", str);
944 }
945 }
946
947 static void
948 hist_trigger_entry_print(struct seq_file *m,
949 struct hist_trigger_data *hist_data, void *key,
950 struct tracing_map_elt *elt)
951 {
952 struct hist_field *key_field;
953 char str[KSYM_SYMBOL_LEN];
954 bool multiline = false;
955 unsigned int i;
956 u64 uval;
957
958 seq_puts(m, "{ ");
959
960 for_each_hist_key_field(i, hist_data) {
961 key_field = hist_data->fields[i];
962
963 if (i > hist_data->n_vals)
964 seq_puts(m, ", ");
965
966 if (key_field->flags & HIST_FIELD_FL_HEX) {
967 uval = *(u64 *)(key + key_field->offset);
968 seq_printf(m, "%s: %llx",
969 key_field->field->name, uval);
970 } else if (key_field->flags & HIST_FIELD_FL_SYM) {
971 uval = *(u64 *)(key + key_field->offset);
972 sprint_symbol_no_offset(str, uval);
973 seq_printf(m, "%s: [%llx] %-45s",
974 key_field->field->name, uval, str);
975 } else if (key_field->flags & HIST_FIELD_FL_SYM_OFFSET) {
976 uval = *(u64 *)(key + key_field->offset);
977 sprint_symbol(str, uval);
978 seq_printf(m, "%s: [%llx] %-55s",
979 key_field->field->name, uval, str);
980 } else if (key_field->flags & HIST_FIELD_FL_EXECNAME) {
981 char *comm = elt->private_data;
982
983 uval = *(u64 *)(key + key_field->offset);
984 seq_printf(m, "%s: %-16s[%10llu]",
985 key_field->field->name, comm, uval);
986 } else if (key_field->flags & HIST_FIELD_FL_SYSCALL) {
987 const char *syscall_name;
988
989 uval = *(u64 *)(key + key_field->offset);
990 syscall_name = get_syscall_name(uval);
991 if (!syscall_name)
992 syscall_name = "unknown_syscall";
993
994 seq_printf(m, "%s: %-30s[%3llu]",
995 key_field->field->name, syscall_name, uval);
996 } else if (key_field->flags & HIST_FIELD_FL_STACKTRACE) {
997 seq_puts(m, "stacktrace:\n");
998 hist_trigger_stacktrace_print(m,
999 key + key_field->offset,
1000 HIST_STACKTRACE_DEPTH);
1001 multiline = true;
1002 } else if (key_field->flags & HIST_FIELD_FL_LOG2) {
1003 seq_printf(m, "%s: ~ 2^%-2llu", key_field->field->name,
1004 *(u64 *)(key + key_field->offset));
1005 } else if (key_field->flags & HIST_FIELD_FL_STRING) {
1006 seq_printf(m, "%s: %-50s", key_field->field->name,
1007 (char *)(key + key_field->offset));
1008 } else {
1009 uval = *(u64 *)(key + key_field->offset);
1010 seq_printf(m, "%s: %10llu", key_field->field->name,
1011 uval);
1012 }
1013 }
1014
1015 if (!multiline)
1016 seq_puts(m, " ");
1017
1018 seq_puts(m, "}");
1019
1020 seq_printf(m, " hitcount: %10llu",
1021 tracing_map_read_sum(elt, HITCOUNT_IDX));
1022
1023 for (i = 1; i < hist_data->n_vals; i++) {
1024 if (hist_data->fields[i]->flags & HIST_FIELD_FL_HEX) {
1025 seq_printf(m, " %s: %10llx",
1026 hist_data->fields[i]->field->name,
1027 tracing_map_read_sum(elt, i));
1028 } else {
1029 seq_printf(m, " %s: %10llu",
1030 hist_data->fields[i]->field->name,
1031 tracing_map_read_sum(elt, i));
1032 }
1033 }
1034
1035 seq_puts(m, "\n");
1036 }
1037
1038 static int print_entries(struct seq_file *m,
1039 struct hist_trigger_data *hist_data)
1040 {
1041 struct tracing_map_sort_entry **sort_entries = NULL;
1042 struct tracing_map *map = hist_data->map;
1043 int i, n_entries;
1044
1045 n_entries = tracing_map_sort_entries(map, hist_data->sort_keys,
1046 hist_data->n_sort_keys,
1047 &sort_entries);
1048 if (n_entries < 0)
1049 return n_entries;
1050
1051 for (i = 0; i < n_entries; i++)
1052 hist_trigger_entry_print(m, hist_data,
1053 sort_entries[i]->key,
1054 sort_entries[i]->elt);
1055
1056 tracing_map_destroy_sort_entries(sort_entries, n_entries);
1057
1058 return n_entries;
1059 }
1060
1061 static void hist_trigger_show(struct seq_file *m,
1062 struct event_trigger_data *data, int n)
1063 {
1064 struct hist_trigger_data *hist_data;
1065 int n_entries, ret = 0;
1066
1067 if (n > 0)
1068 seq_puts(m, "\n\n");
1069
1070 seq_puts(m, "# event histogram\n#\n# trigger info: ");
1071 data->ops->print(m, data->ops, data);
1072 seq_puts(m, "#\n\n");
1073
1074 hist_data = data->private_data;
1075 n_entries = print_entries(m, hist_data);
1076 if (n_entries < 0) {
1077 ret = n_entries;
1078 n_entries = 0;
1079 }
1080
1081 seq_printf(m, "\nTotals:\n Hits: %llu\n Entries: %u\n Dropped: %llu\n",
1082 (u64)atomic64_read(&hist_data->map->hits),
1083 n_entries, (u64)atomic64_read(&hist_data->map->drops));
1084 }
1085
1086 static int hist_show(struct seq_file *m, void *v)
1087 {
1088 struct event_trigger_data *data;
1089 struct trace_event_file *event_file;
1090 int n = 0, ret = 0;
1091
1092 mutex_lock(&event_mutex);
1093
1094 event_file = event_file_data(m->private);
1095 if (unlikely(!event_file)) {
1096 ret = -ENODEV;
1097 goto out_unlock;
1098 }
1099
1100 list_for_each_entry_rcu(data, &event_file->triggers, list) {
1101 if (data->cmd_ops->trigger_type == ETT_EVENT_HIST)
1102 hist_trigger_show(m, data, n++);
1103 }
1104
1105 out_unlock:
1106 mutex_unlock(&event_mutex);
1107
1108 return ret;
1109 }
1110
1111 static int event_hist_open(struct inode *inode, struct file *file)
1112 {
1113 return single_open(file, hist_show, file);
1114 }
1115
1116 const struct file_operations event_hist_fops = {
1117 .open = event_hist_open,
1118 .read = seq_read,
1119 .llseek = seq_lseek,
1120 .release = single_release,
1121 };
1122
1123 static const char *get_hist_field_flags(struct hist_field *hist_field)
1124 {
1125 const char *flags_str = NULL;
1126
1127 if (hist_field->flags & HIST_FIELD_FL_HEX)
1128 flags_str = "hex";
1129 else if (hist_field->flags & HIST_FIELD_FL_SYM)
1130 flags_str = "sym";
1131 else if (hist_field->flags & HIST_FIELD_FL_SYM_OFFSET)
1132 flags_str = "sym-offset";
1133 else if (hist_field->flags & HIST_FIELD_FL_EXECNAME)
1134 flags_str = "execname";
1135 else if (hist_field->flags & HIST_FIELD_FL_SYSCALL)
1136 flags_str = "syscall";
1137 else if (hist_field->flags & HIST_FIELD_FL_LOG2)
1138 flags_str = "log2";
1139
1140 return flags_str;
1141 }
1142
1143 static void hist_field_print(struct seq_file *m, struct hist_field *hist_field)
1144 {
1145 seq_printf(m, "%s", hist_field->field->name);
1146 if (hist_field->flags) {
1147 const char *flags_str = get_hist_field_flags(hist_field);
1148
1149 if (flags_str)
1150 seq_printf(m, ".%s", flags_str);
1151 }
1152 }
1153
1154 static int event_hist_trigger_print(struct seq_file *m,
1155 struct event_trigger_ops *ops,
1156 struct event_trigger_data *data)
1157 {
1158 struct hist_trigger_data *hist_data = data->private_data;
1159 struct hist_field *key_field;
1160 unsigned int i;
1161
1162 seq_puts(m, "hist:");
1163
1164 if (data->name)
1165 seq_printf(m, "%s:", data->name);
1166
1167 seq_puts(m, "keys=");
1168
1169 for_each_hist_key_field(i, hist_data) {
1170 key_field = hist_data->fields[i];
1171
1172 if (i > hist_data->n_vals)
1173 seq_puts(m, ",");
1174
1175 if (key_field->flags & HIST_FIELD_FL_STACKTRACE)
1176 seq_puts(m, "stacktrace");
1177 else
1178 hist_field_print(m, key_field);
1179 }
1180
1181 seq_puts(m, ":vals=");
1182
1183 for_each_hist_val_field(i, hist_data) {
1184 if (i == HITCOUNT_IDX)
1185 seq_puts(m, "hitcount");
1186 else {
1187 seq_puts(m, ",");
1188 hist_field_print(m, hist_data->fields[i]);
1189 }
1190 }
1191
1192 seq_puts(m, ":sort=");
1193
1194 for (i = 0; i < hist_data->n_sort_keys; i++) {
1195 struct tracing_map_sort_key *sort_key;
1196
1197 sort_key = &hist_data->sort_keys[i];
1198
1199 if (i > 0)
1200 seq_puts(m, ",");
1201
1202 if (sort_key->field_idx == HITCOUNT_IDX)
1203 seq_puts(m, "hitcount");
1204 else {
1205 unsigned int idx = sort_key->field_idx;
1206
1207 if (WARN_ON(idx >= TRACING_MAP_FIELDS_MAX))
1208 return -EINVAL;
1209
1210 hist_field_print(m, hist_data->fields[idx]);
1211 }
1212
1213 if (sort_key->descending)
1214 seq_puts(m, ".descending");
1215 }
1216
1217 seq_printf(m, ":size=%u", (1 << hist_data->map->map_bits));
1218
1219 if (data->filter_str)
1220 seq_printf(m, " if %s", data->filter_str);
1221
1222 if (data->paused)
1223 seq_puts(m, " [paused]");
1224 else
1225 seq_puts(m, " [active]");
1226
1227 seq_putc(m, '\n');
1228
1229 return 0;
1230 }
1231
1232 static int event_hist_trigger_init(struct event_trigger_ops *ops,
1233 struct event_trigger_data *data)
1234 {
1235 struct hist_trigger_data *hist_data = data->private_data;
1236
1237 if (!data->ref && hist_data->attrs->name)
1238 save_named_trigger(hist_data->attrs->name, data);
1239
1240 data->ref++;
1241
1242 return 0;
1243 }
1244
1245 static void event_hist_trigger_free(struct event_trigger_ops *ops,
1246 struct event_trigger_data *data)
1247 {
1248 struct hist_trigger_data *hist_data = data->private_data;
1249
1250 if (WARN_ON_ONCE(data->ref <= 0))
1251 return;
1252
1253 data->ref--;
1254 if (!data->ref) {
1255 if (data->name)
1256 del_named_trigger(data);
1257 trigger_data_free(data);
1258 destroy_hist_data(hist_data);
1259 }
1260 }
1261
1262 static struct event_trigger_ops event_hist_trigger_ops = {
1263 .func = event_hist_trigger,
1264 .print = event_hist_trigger_print,
1265 .init = event_hist_trigger_init,
1266 .free = event_hist_trigger_free,
1267 };
1268
1269 static int event_hist_trigger_named_init(struct event_trigger_ops *ops,
1270 struct event_trigger_data *data)
1271 {
1272 data->ref++;
1273
1274 save_named_trigger(data->named_data->name, data);
1275
1276 event_hist_trigger_init(ops, data->named_data);
1277
1278 return 0;
1279 }
1280
1281 static void event_hist_trigger_named_free(struct event_trigger_ops *ops,
1282 struct event_trigger_data *data)
1283 {
1284 if (WARN_ON_ONCE(data->ref <= 0))
1285 return;
1286
1287 event_hist_trigger_free(ops, data->named_data);
1288
1289 data->ref--;
1290 if (!data->ref) {
1291 del_named_trigger(data);
1292 trigger_data_free(data);
1293 }
1294 }
1295
1296 static struct event_trigger_ops event_hist_trigger_named_ops = {
1297 .func = event_hist_trigger,
1298 .print = event_hist_trigger_print,
1299 .init = event_hist_trigger_named_init,
1300 .free = event_hist_trigger_named_free,
1301 };
1302
1303 static struct event_trigger_ops *event_hist_get_trigger_ops(char *cmd,
1304 char *param)
1305 {
1306 return &event_hist_trigger_ops;
1307 }
1308
1309 static void hist_clear(struct event_trigger_data *data)
1310 {
1311 struct hist_trigger_data *hist_data = data->private_data;
1312
1313 if (data->name)
1314 pause_named_trigger(data);
1315
1316 synchronize_sched();
1317
1318 tracing_map_clear(hist_data->map);
1319
1320 if (data->name)
1321 unpause_named_trigger(data);
1322 }
1323
1324 static bool compatible_field(struct ftrace_event_field *field,
1325 struct ftrace_event_field *test_field)
1326 {
1327 if (field == test_field)
1328 return true;
1329 if (field == NULL || test_field == NULL)
1330 return false;
1331 if (strcmp(field->name, test_field->name) != 0)
1332 return false;
1333 if (strcmp(field->type, test_field->type) != 0)
1334 return false;
1335 if (field->size != test_field->size)
1336 return false;
1337 if (field->is_signed != test_field->is_signed)
1338 return false;
1339
1340 return true;
1341 }
1342
1343 static bool hist_trigger_match(struct event_trigger_data *data,
1344 struct event_trigger_data *data_test,
1345 struct event_trigger_data *named_data,
1346 bool ignore_filter)
1347 {
1348 struct tracing_map_sort_key *sort_key, *sort_key_test;
1349 struct hist_trigger_data *hist_data, *hist_data_test;
1350 struct hist_field *key_field, *key_field_test;
1351 unsigned int i;
1352
1353 if (named_data && (named_data != data_test) &&
1354 (named_data != data_test->named_data))
1355 return false;
1356
1357 if (!named_data && is_named_trigger(data_test))
1358 return false;
1359
1360 hist_data = data->private_data;
1361 hist_data_test = data_test->private_data;
1362
1363 if (hist_data->n_vals != hist_data_test->n_vals ||
1364 hist_data->n_fields != hist_data_test->n_fields ||
1365 hist_data->n_sort_keys != hist_data_test->n_sort_keys)
1366 return false;
1367
1368 if (!ignore_filter) {
1369 if ((data->filter_str && !data_test->filter_str) ||
1370 (!data->filter_str && data_test->filter_str))
1371 return false;
1372 }
1373
1374 for_each_hist_field(i, hist_data) {
1375 key_field = hist_data->fields[i];
1376 key_field_test = hist_data_test->fields[i];
1377
1378 if (key_field->flags != key_field_test->flags)
1379 return false;
1380 if (!compatible_field(key_field->field, key_field_test->field))
1381 return false;
1382 if (key_field->offset != key_field_test->offset)
1383 return false;
1384 }
1385
1386 for (i = 0; i < hist_data->n_sort_keys; i++) {
1387 sort_key = &hist_data->sort_keys[i];
1388 sort_key_test = &hist_data_test->sort_keys[i];
1389
1390 if (sort_key->field_idx != sort_key_test->field_idx ||
1391 sort_key->descending != sort_key_test->descending)
1392 return false;
1393 }
1394
1395 if (!ignore_filter && data->filter_str &&
1396 (strcmp(data->filter_str, data_test->filter_str) != 0))
1397 return false;
1398
1399 return true;
1400 }
1401
1402 static int hist_register_trigger(char *glob, struct event_trigger_ops *ops,
1403 struct event_trigger_data *data,
1404 struct trace_event_file *file)
1405 {
1406 struct hist_trigger_data *hist_data = data->private_data;
1407 struct event_trigger_data *test, *named_data = NULL;
1408 int ret = 0;
1409
1410 if (hist_data->attrs->name) {
1411 named_data = find_named_trigger(hist_data->attrs->name);
1412 if (named_data) {
1413 if (!hist_trigger_match(data, named_data, named_data,
1414 true)) {
1415 ret = -EINVAL;
1416 goto out;
1417 }
1418 }
1419 }
1420
1421 if (hist_data->attrs->name && !named_data)
1422 goto new;
1423
1424 list_for_each_entry_rcu(test, &file->triggers, list) {
1425 if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
1426 if (!hist_trigger_match(data, test, named_data, false))
1427 continue;
1428 if (hist_data->attrs->pause)
1429 test->paused = true;
1430 else if (hist_data->attrs->cont)
1431 test->paused = false;
1432 else if (hist_data->attrs->clear)
1433 hist_clear(test);
1434 else
1435 ret = -EEXIST;
1436 goto out;
1437 }
1438 }
1439 new:
1440 if (hist_data->attrs->cont || hist_data->attrs->clear) {
1441 ret = -ENOENT;
1442 goto out;
1443 }
1444
1445 if (hist_data->attrs->pause)
1446 data->paused = true;
1447
1448 if (named_data) {
1449 destroy_hist_data(data->private_data);
1450 data->private_data = named_data->private_data;
1451 set_named_trigger_data(data, named_data);
1452 data->ops = &event_hist_trigger_named_ops;
1453 }
1454
1455 if (data->ops->init) {
1456 ret = data->ops->init(data->ops, data);
1457 if (ret < 0)
1458 goto out;
1459 }
1460
1461 list_add_rcu(&data->list, &file->triggers);
1462 ret++;
1463
1464 update_cond_flag(file);
1465
1466 if (trace_event_trigger_enable_disable(file, 1) < 0) {
1467 list_del_rcu(&data->list);
1468 update_cond_flag(file);
1469 ret--;
1470 }
1471 out:
1472 return ret;
1473 }
1474
1475 static void hist_unregister_trigger(char *glob, struct event_trigger_ops *ops,
1476 struct event_trigger_data *data,
1477 struct trace_event_file *file)
1478 {
1479 struct hist_trigger_data *hist_data = data->private_data;
1480 struct event_trigger_data *test, *named_data = NULL;
1481 bool unregistered = false;
1482
1483 if (hist_data->attrs->name)
1484 named_data = find_named_trigger(hist_data->attrs->name);
1485
1486 list_for_each_entry_rcu(test, &file->triggers, list) {
1487 if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
1488 if (!hist_trigger_match(data, test, named_data, false))
1489 continue;
1490 unregistered = true;
1491 list_del_rcu(&test->list);
1492 trace_event_trigger_enable_disable(file, 0);
1493 update_cond_flag(file);
1494 break;
1495 }
1496 }
1497
1498 if (unregistered && test->ops->free)
1499 test->ops->free(test->ops, test);
1500 }
1501
1502 static void hist_unreg_all(struct trace_event_file *file)
1503 {
1504 struct event_trigger_data *test, *n;
1505
1506 list_for_each_entry_safe(test, n, &file->triggers, list) {
1507 if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
1508 list_del_rcu(&test->list);
1509 trace_event_trigger_enable_disable(file, 0);
1510 update_cond_flag(file);
1511 if (test->ops->free)
1512 test->ops->free(test->ops, test);
1513 }
1514 }
1515 }
1516
1517 static int event_hist_trigger_func(struct event_command *cmd_ops,
1518 struct trace_event_file *file,
1519 char *glob, char *cmd, char *param)
1520 {
1521 unsigned int hist_trigger_bits = TRACING_MAP_BITS_DEFAULT;
1522 struct event_trigger_data *trigger_data;
1523 struct hist_trigger_attrs *attrs;
1524 struct event_trigger_ops *trigger_ops;
1525 struct hist_trigger_data *hist_data;
1526 char *trigger;
1527 int ret = 0;
1528
1529 if (!param)
1530 return -EINVAL;
1531
1532 /* separate the trigger from the filter (k:v [if filter]) */
1533 trigger = strsep(&param, " \t");
1534 if (!trigger)
1535 return -EINVAL;
1536
1537 attrs = parse_hist_trigger_attrs(trigger);
1538 if (IS_ERR(attrs))
1539 return PTR_ERR(attrs);
1540
1541 if (attrs->map_bits)
1542 hist_trigger_bits = attrs->map_bits;
1543
1544 hist_data = create_hist_data(hist_trigger_bits, attrs, file);
1545 if (IS_ERR(hist_data)) {
1546 destroy_hist_trigger_attrs(attrs);
1547 return PTR_ERR(hist_data);
1548 }
1549
1550 trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);
1551
1552 ret = -ENOMEM;
1553 trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
1554 if (!trigger_data)
1555 goto out_free;
1556
1557 trigger_data->count = -1;
1558 trigger_data->ops = trigger_ops;
1559 trigger_data->cmd_ops = cmd_ops;
1560
1561 INIT_LIST_HEAD(&trigger_data->list);
1562 RCU_INIT_POINTER(trigger_data->filter, NULL);
1563
1564 trigger_data->private_data = hist_data;
1565
1566 /* if param is non-empty, it's supposed to be a filter */
1567 if (param && cmd_ops->set_filter) {
1568 ret = cmd_ops->set_filter(param, trigger_data, file);
1569 if (ret < 0)
1570 goto out_free;
1571 }
1572
1573 if (glob[0] == '!') {
1574 cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file);
1575 ret = 0;
1576 goto out_free;
1577 }
1578
1579 ret = cmd_ops->reg(glob, trigger_ops, trigger_data, file);
1580 /*
1581 * The above returns on success the # of triggers registered,
1582 * but if it didn't register any it returns zero. Consider no
1583 * triggers registered a failure too.
1584 */
1585 if (!ret) {
1586 if (!(attrs->pause || attrs->cont || attrs->clear))
1587 ret = -ENOENT;
1588 goto out_free;
1589 } else if (ret < 0)
1590 goto out_free;
1591 /* Just return zero, not the number of registered triggers */
1592 ret = 0;
1593 out:
1594 return ret;
1595 out_free:
1596 if (cmd_ops->set_filter)
1597 cmd_ops->set_filter(NULL, trigger_data, NULL);
1598
1599 kfree(trigger_data);
1600
1601 destroy_hist_data(hist_data);
1602 goto out;
1603 }
1604
1605 static struct event_command trigger_hist_cmd = {
1606 .name = "hist",
1607 .trigger_type = ETT_EVENT_HIST,
1608 .flags = EVENT_CMD_FL_NEEDS_REC,
1609 .func = event_hist_trigger_func,
1610 .reg = hist_register_trigger,
1611 .unreg = hist_unregister_trigger,
1612 .unreg_all = hist_unreg_all,
1613 .get_trigger_ops = event_hist_get_trigger_ops,
1614 .set_filter = set_trigger_filter,
1615 };
1616
1617 __init int register_trigger_hist_cmd(void)
1618 {
1619 int ret;
1620
1621 ret = register_event_command(&trigger_hist_cmd);
1622 WARN_ON(ret < 0);
1623
1624 return ret;
1625 }
1626
1627 static void
1628 hist_enable_trigger(struct event_trigger_data *data, void *rec)
1629 {
1630 struct enable_trigger_data *enable_data = data->private_data;
1631 struct event_trigger_data *test;
1632
1633 list_for_each_entry_rcu(test, &enable_data->file->triggers, list) {
1634 if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
1635 if (enable_data->enable)
1636 test->paused = false;
1637 else
1638 test->paused = true;
1639 }
1640 }
1641 }
1642
1643 static void
1644 hist_enable_count_trigger(struct event_trigger_data *data, void *rec)
1645 {
1646 if (!data->count)
1647 return;
1648
1649 if (data->count != -1)
1650 (data->count)--;
1651
1652 hist_enable_trigger(data, rec);
1653 }
1654
1655 static struct event_trigger_ops hist_enable_trigger_ops = {
1656 .func = hist_enable_trigger,
1657 .print = event_enable_trigger_print,
1658 .init = event_trigger_init,
1659 .free = event_enable_trigger_free,
1660 };
1661
1662 static struct event_trigger_ops hist_enable_count_trigger_ops = {
1663 .func = hist_enable_count_trigger,
1664 .print = event_enable_trigger_print,
1665 .init = event_trigger_init,
1666 .free = event_enable_trigger_free,
1667 };
1668
1669 static struct event_trigger_ops hist_disable_trigger_ops = {
1670 .func = hist_enable_trigger,
1671 .print = event_enable_trigger_print,
1672 .init = event_trigger_init,
1673 .free = event_enable_trigger_free,
1674 };
1675
1676 static struct event_trigger_ops hist_disable_count_trigger_ops = {
1677 .func = hist_enable_count_trigger,
1678 .print = event_enable_trigger_print,
1679 .init = event_trigger_init,
1680 .free = event_enable_trigger_free,
1681 };
1682
1683 static struct event_trigger_ops *
1684 hist_enable_get_trigger_ops(char *cmd, char *param)
1685 {
1686 struct event_trigger_ops *ops;
1687 bool enable;
1688
1689 enable = (strcmp(cmd, ENABLE_HIST_STR) == 0);
1690
1691 if (enable)
1692 ops = param ? &hist_enable_count_trigger_ops :
1693 &hist_enable_trigger_ops;
1694 else
1695 ops = param ? &hist_disable_count_trigger_ops :
1696 &hist_disable_trigger_ops;
1697
1698 return ops;
1699 }
1700
1701 static void hist_enable_unreg_all(struct trace_event_file *file)
1702 {
1703 struct event_trigger_data *test, *n;
1704
1705 list_for_each_entry_safe(test, n, &file->triggers, list) {
1706 if (test->cmd_ops->trigger_type == ETT_HIST_ENABLE) {
1707 list_del_rcu(&test->list);
1708 update_cond_flag(file);
1709 trace_event_trigger_enable_disable(file, 0);
1710 if (test->ops->free)
1711 test->ops->free(test->ops, test);
1712 }
1713 }
1714 }
1715
1716 static struct event_command trigger_hist_enable_cmd = {
1717 .name = ENABLE_HIST_STR,
1718 .trigger_type = ETT_HIST_ENABLE,
1719 .func = event_enable_trigger_func,
1720 .reg = event_enable_register_trigger,
1721 .unreg = event_enable_unregister_trigger,
1722 .unreg_all = hist_enable_unreg_all,
1723 .get_trigger_ops = hist_enable_get_trigger_ops,
1724 .set_filter = set_trigger_filter,
1725 };
1726
1727 static struct event_command trigger_hist_disable_cmd = {
1728 .name = DISABLE_HIST_STR,
1729 .trigger_type = ETT_HIST_ENABLE,
1730 .func = event_enable_trigger_func,
1731 .reg = event_enable_register_trigger,
1732 .unreg = event_enable_unregister_trigger,
1733 .unreg_all = hist_enable_unreg_all,
1734 .get_trigger_ops = hist_enable_get_trigger_ops,
1735 .set_filter = set_trigger_filter,
1736 };
1737
1738 static __init void unregister_trigger_hist_enable_disable_cmds(void)
1739 {
1740 unregister_event_command(&trigger_hist_enable_cmd);
1741 unregister_event_command(&trigger_hist_disable_cmd);
1742 }
1743
1744 __init int register_trigger_hist_enable_disable_cmds(void)
1745 {
1746 int ret;
1747
1748 ret = register_event_command(&trigger_hist_enable_cmd);
1749 if (WARN_ON(ret < 0))
1750 return ret;
1751 ret = register_event_command(&trigger_hist_disable_cmd);
1752 if (WARN_ON(ret < 0))
1753 unregister_trigger_hist_enable_disable_cmds();
1754
1755 return ret;
1756 }
Linux with added FPC-III support