1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * trace_events_hist - trace event hist triggers
4  *
5  * Copyright (C) 2015 Tom Zanussi <tom.zanussi@linux.intel.com>
6  */
7 
8 #include <linux/module.h>
9 #include <linux/kallsyms.h>
10 #include <linux/security.h>
11 #include <linux/mutex.h>
12 #include <linux/slab.h>
13 #include <linux/stacktrace.h>
14 #include <linux/rculist.h>
15 #include <linux/tracefs.h>
16 
17 /* for gfp flag names */
18 #include <linux/trace_events.h>
19 #include <trace/events/mmflags.h>
20 
21 #include "tracing_map.h"
22 #include "trace_synth.h"
23 
24 #define ERRORS								\
25 	C(NONE,			"No error"),				\
26 	C(DUPLICATE_VAR,	"Variable already defined"),		\
27 	C(VAR_NOT_UNIQUE,	"Variable name not unique, need to use fully qualified name (subsys.event.var) for variable"), \
28 	C(TOO_MANY_VARS,	"Too many variables defined"),		\
29 	C(MALFORMED_ASSIGNMENT,	"Malformed assignment"),		\
30 	C(NAMED_MISMATCH,	"Named hist trigger doesn't match existing named trigger (includes variables)"), \
31 	C(TRIGGER_EEXIST,	"Hist trigger already exists"),		\
32 	C(TRIGGER_ENOENT_CLEAR,	"Can't clear or continue a nonexistent hist trigger"), \
33 	C(SET_CLOCK_FAIL,	"Couldn't set trace_clock"),		\
34 	C(BAD_FIELD_MODIFIER,	"Invalid field modifier"),		\
35 	C(TOO_MANY_SUBEXPR,	"Too many subexpressions (3 max)"),	\
36 	C(TIMESTAMP_MISMATCH,	"Timestamp units in expression don't match"), \
37 	C(TOO_MANY_FIELD_VARS,	"Too many field variables defined"),	\
38 	C(EVENT_FILE_NOT_FOUND,	"Event file not found"),		\
39 	C(HIST_NOT_FOUND,	"Matching event histogram not found"),	\
40 	C(HIST_CREATE_FAIL,	"Couldn't create histogram for field"),	\
41 	C(SYNTH_VAR_NOT_FOUND,	"Couldn't find synthetic variable"),	\
42 	C(SYNTH_EVENT_NOT_FOUND,"Couldn't find synthetic event"),	\
43 	C(SYNTH_TYPE_MISMATCH,	"Param type doesn't match synthetic event field type"), \
44 	C(SYNTH_COUNT_MISMATCH,	"Param count doesn't match synthetic event field count"), \
45 	C(FIELD_VAR_PARSE_FAIL,	"Couldn't parse field variable"),	\
46 	C(VAR_CREATE_FIND_FAIL,	"Couldn't create or find variable"),	\
47 	C(ONX_NOT_VAR,		"For onmax(x) or onchange(x), x must be a variable"), \
48 	C(ONX_VAR_NOT_FOUND,	"Couldn't find onmax or onchange variable"), \
49 	C(ONX_VAR_CREATE_FAIL,	"Couldn't create onmax or onchange variable"), \
50 	C(FIELD_VAR_CREATE_FAIL,"Couldn't create field variable"),	\
51 	C(TOO_MANY_PARAMS,	"Too many action params"),		\
52 	C(PARAM_NOT_FOUND,	"Couldn't find param"),			\
53 	C(INVALID_PARAM,	"Invalid action param"),		\
54 	C(ACTION_NOT_FOUND,	"No action found"),			\
55 	C(NO_SAVE_PARAMS,	"No params found for save()"),		\
56 	C(TOO_MANY_SAVE_ACTIONS,"Can't have more than one save() action per hist"), \
57 	C(ACTION_MISMATCH,	"Handler doesn't support action"),	\
58 	C(NO_CLOSING_PAREN,	"No closing paren found"),		\
59 	C(SUBSYS_NOT_FOUND,	"Missing subsystem"),			\
60 	C(INVALID_SUBSYS_EVENT,	"Invalid subsystem or event name"),	\
61 	C(INVALID_REF_KEY,	"Using variable references in keys not supported"), \
62 	C(VAR_NOT_FOUND,	"Couldn't find variable"),		\
63 	C(FIELD_NOT_FOUND,	"Couldn't find field"),			\
64 	C(EMPTY_ASSIGNMENT,	"Empty assignment"),			\
65 	C(INVALID_SORT_MODIFIER,"Invalid sort modifier"),		\
66 	C(EMPTY_SORT_FIELD,	"Empty sort field"),			\
67 	C(TOO_MANY_SORT_FIELDS,	"Too many sort fields (Max = 2)"),	\
68 	C(INVALID_SORT_FIELD,	"Sort field must be a key or a val"),	\
69 	C(INVALID_STR_OPERAND,	"String type can not be an operand in expression"), \
70 	C(EXPECT_NUMBER,	"Expecting numeric literal"),		\
71 	C(UNARY_MINUS_SUBEXPR,	"Unary minus not supported in sub-expressions"), \
72 	C(DIVISION_BY_ZERO,	"Division by zero"),			\
73 	C(NEED_NOHC_VAL,	"Non-hitcount value is required for 'nohitcount'"),
74 
75 #undef C
76 #define C(a, b)		HIST_ERR_##a
77 
78 enum { ERRORS };
79 
80 #undef C
81 #define C(a, b)		b
82 
83 static const char *err_text[] = { ERRORS };
84 
85 struct hist_field;
86 
87 typedef u64 (*hist_field_fn_t) (struct hist_field *field,
88 				struct tracing_map_elt *elt,
89 				struct trace_buffer *buffer,
90 				struct ring_buffer_event *rbe,
91 				void *event);
92 
93 #define HIST_FIELD_OPERANDS_MAX	2
94 #define HIST_FIELDS_MAX		(TRACING_MAP_FIELDS_MAX + TRACING_MAP_VARS_MAX)
95 #define HIST_ACTIONS_MAX	8
96 #define HIST_CONST_DIGITS_MAX	21
97 #define HIST_DIV_SHIFT		20  /* For optimizing division by constants */
98 
99 enum field_op_id {
100 	FIELD_OP_NONE,
101 	FIELD_OP_PLUS,
102 	FIELD_OP_MINUS,
103 	FIELD_OP_UNARY_MINUS,
104 	FIELD_OP_DIV,
105 	FIELD_OP_MULT,
106 };
107 
108 enum hist_field_fn {
109 	HIST_FIELD_FN_NOP,
110 	HIST_FIELD_FN_VAR_REF,
111 	HIST_FIELD_FN_COUNTER,
112 	HIST_FIELD_FN_CONST,
113 	HIST_FIELD_FN_LOG2,
114 	HIST_FIELD_FN_BUCKET,
115 	HIST_FIELD_FN_TIMESTAMP,
116 	HIST_FIELD_FN_CPU,
117 	HIST_FIELD_FN_STRING,
118 	HIST_FIELD_FN_DYNSTRING,
119 	HIST_FIELD_FN_RELDYNSTRING,
120 	HIST_FIELD_FN_PSTRING,
121 	HIST_FIELD_FN_S64,
122 	HIST_FIELD_FN_U64,
123 	HIST_FIELD_FN_S32,
124 	HIST_FIELD_FN_U32,
125 	HIST_FIELD_FN_S16,
126 	HIST_FIELD_FN_U16,
127 	HIST_FIELD_FN_S8,
128 	HIST_FIELD_FN_U8,
129 	HIST_FIELD_FN_UMINUS,
130 	HIST_FIELD_FN_MINUS,
131 	HIST_FIELD_FN_PLUS,
132 	HIST_FIELD_FN_DIV,
133 	HIST_FIELD_FN_MULT,
134 	HIST_FIELD_FN_DIV_POWER2,
135 	HIST_FIELD_FN_DIV_NOT_POWER2,
136 	HIST_FIELD_FN_DIV_MULT_SHIFT,
137 	HIST_FIELD_FN_EXECNAME,
138 	HIST_FIELD_FN_STACK,
139 };
140 
141 /*
142  * A hist_var (histogram variable) contains variable information for
143  * hist_fields having the HIST_FIELD_FL_VAR or HIST_FIELD_FL_VAR_REF
144  * flag set.  A hist_var has a variable name e.g. ts0, and is
145  * associated with a given histogram trigger, as specified by
146  * hist_data.  The hist_var idx is the unique index assigned to the
147  * variable by the hist trigger's tracing_map.  The idx is what is
148  * used to set a variable's value and, by a variable reference, to
149  * retrieve it.
150  */
151 struct hist_var {
152 	char				*name;
153 	struct hist_trigger_data	*hist_data;
154 	unsigned int			idx;
155 };
156 
157 struct hist_field {
158 	struct ftrace_event_field	*field;
159 	unsigned long			flags;
160 	unsigned long			buckets;
161 	const char			*type;
162 	struct hist_field		*operands[HIST_FIELD_OPERANDS_MAX];
163 	struct hist_trigger_data	*hist_data;
164 	enum hist_field_fn		fn_num;
165 	unsigned int			ref;
166 	unsigned int			size;
167 	unsigned int			offset;
168 	unsigned int                    is_signed;
169 
170 	/*
171 	 * Variable fields contain variable-specific info in var.
172 	 */
173 	struct hist_var			var;
174 	enum field_op_id		operator;
175 	char				*system;
176 	char				*event_name;
177 
178 	/*
179 	 * The name field is used for EXPR and VAR_REF fields.  VAR
180 	 * fields contain the variable name in var.name.
181 	 */
182 	char				*name;
183 
184 	/*
185 	 * When a histogram trigger is hit, if it has any references
186 	 * to variables, the values of those variables are collected
187 	 * into a var_ref_vals array by resolve_var_refs().  The
188 	 * current value of each variable is read from the tracing_map
189 	 * using the hist field's hist_var.idx and entered into the
190 	 * var_ref_idx entry i.e. var_ref_vals[var_ref_idx].
191 	 */
192 	unsigned int			var_ref_idx;
193 	bool                            read_once;
194 
195 	unsigned int			var_str_idx;
196 
197 	/* Numeric literals are represented as u64 */
198 	u64				constant;
199 	/* Used to optimize division by constants */
200 	u64				div_multiplier;
201 };
202 
203 static u64 hist_fn_call(struct hist_field *hist_field,
204 			struct tracing_map_elt *elt,
205 			struct trace_buffer *buffer,
206 			struct ring_buffer_event *rbe,
207 			void *event);
208 
209 static u64 hist_field_const(struct hist_field *field,
210 			   struct tracing_map_elt *elt,
211 			   struct trace_buffer *buffer,
212 			   struct ring_buffer_event *rbe,
213 			   void *event)
214 {
215 	return field->constant;
216 }
217 
218 static u64 hist_field_counter(struct hist_field *field,
219 			      struct tracing_map_elt *elt,
220 			      struct trace_buffer *buffer,
221 			      struct ring_buffer_event *rbe,
222 			      void *event)
223 {
224 	return 1;
225 }
226 
227 static u64 hist_field_string(struct hist_field *hist_field,
228 			     struct tracing_map_elt *elt,
229 			     struct trace_buffer *buffer,
230 			     struct ring_buffer_event *rbe,
231 			     void *event)
232 {
233 	char *addr = (char *)(event + hist_field->field->offset);
234 
235 	return (u64)(unsigned long)addr;
236 }
237 
238 static u64 hist_field_dynstring(struct hist_field *hist_field,
239 				struct tracing_map_elt *elt,
240 				struct trace_buffer *buffer,
241 				struct ring_buffer_event *rbe,
242 				void *event)
243 {
244 	u32 str_item = *(u32 *)(event + hist_field->field->offset);
245 	int str_loc = str_item & 0xffff;
246 	char *addr = (char *)(event + str_loc);
247 
248 	return (u64)(unsigned long)addr;
249 }
250 
251 static u64 hist_field_reldynstring(struct hist_field *hist_field,
252 				   struct tracing_map_elt *elt,
253 				   struct trace_buffer *buffer,
254 				   struct ring_buffer_event *rbe,
255 				   void *event)
256 {
257 	u32 *item = event + hist_field->field->offset;
258 	u32 str_item = *item;
259 	int str_loc = str_item & 0xffff;
260 	char *addr = (char *)&item[1] + str_loc;
261 
262 	return (u64)(unsigned long)addr;
263 }
264 
265 static u64 hist_field_pstring(struct hist_field *hist_field,
266 			      struct tracing_map_elt *elt,
267 			      struct trace_buffer *buffer,
268 			      struct ring_buffer_event *rbe,
269 			      void *event)
270 {
271 	char **addr = (char **)(event + hist_field->field->offset);
272 
273 	return (u64)(unsigned long)*addr;
274 }
275 
276 static u64 hist_field_log2(struct hist_field *hist_field,
277 			   struct tracing_map_elt *elt,
278 			   struct trace_buffer *buffer,
279 			   struct ring_buffer_event *rbe,
280 			   void *event)
281 {
282 	struct hist_field *operand = hist_field->operands[0];
283 
284 	u64 val = hist_fn_call(operand, elt, buffer, rbe, event);
285 
286 	return (u64) ilog2(roundup_pow_of_two(val));
287 }
288 
289 static u64 hist_field_bucket(struct hist_field *hist_field,
290 			     struct tracing_map_elt *elt,
291 			     struct trace_buffer *buffer,
292 			     struct ring_buffer_event *rbe,
293 			     void *event)
294 {
295 	struct hist_field *operand = hist_field->operands[0];
296 	unsigned long buckets = hist_field->buckets;
297 
298 	u64 val = hist_fn_call(operand, elt, buffer, rbe, event);
299 
300 	if (WARN_ON_ONCE(!buckets))
301 		return val;
302 
303 	if (val >= LONG_MAX)
304 		val = div64_ul(val, buckets);
305 	else
306 		val = (u64)((unsigned long)val / buckets);
307 	return val * buckets;
308 }
309 
310 static u64 hist_field_plus(struct hist_field *hist_field,
311 			   struct tracing_map_elt *elt,
312 			   struct trace_buffer *buffer,
313 			   struct ring_buffer_event *rbe,
314 			   void *event)
315 {
316 	struct hist_field *operand1 = hist_field->operands[0];
317 	struct hist_field *operand2 = hist_field->operands[1];
318 
319 	u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);
320 	u64 val2 = hist_fn_call(operand2, elt, buffer, rbe, event);
321 
322 	return val1 + val2;
323 }
324 
325 static u64 hist_field_minus(struct hist_field *hist_field,
326 			    struct tracing_map_elt *elt,
327 			    struct trace_buffer *buffer,
328 			    struct ring_buffer_event *rbe,
329 			    void *event)
330 {
331 	struct hist_field *operand1 = hist_field->operands[0];
332 	struct hist_field *operand2 = hist_field->operands[1];
333 
334 	u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);
335 	u64 val2 = hist_fn_call(operand2, elt, buffer, rbe, event);
336 
337 	return val1 - val2;
338 }
339 
340 static u64 hist_field_div(struct hist_field *hist_field,
341 			   struct tracing_map_elt *elt,
342 			   struct trace_buffer *buffer,
343 			   struct ring_buffer_event *rbe,
344 			   void *event)
345 {
346 	struct hist_field *operand1 = hist_field->operands[0];
347 	struct hist_field *operand2 = hist_field->operands[1];
348 
349 	u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);
350 	u64 val2 = hist_fn_call(operand2, elt, buffer, rbe, event);
351 
352 	/* Return -1 for the undefined case */
353 	if (!val2)
354 		return -1;
355 
356 	/* Use shift if the divisor is a power of 2 */
357 	if (!(val2 & (val2 - 1)))
358 		return val1 >> __ffs64(val2);
359 
360 	return div64_u64(val1, val2);
361 }
362 
363 static u64 div_by_power_of_two(struct hist_field *hist_field,
364 				struct tracing_map_elt *elt,
365 				struct trace_buffer *buffer,
366 				struct ring_buffer_event *rbe,
367 				void *event)
368 {
369 	struct hist_field *operand1 = hist_field->operands[0];
370 	struct hist_field *operand2 = hist_field->operands[1];
371 
372 	u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);
373 
374 	return val1 >> __ffs64(operand2->constant);
375 }
376 
377 static u64 div_by_not_power_of_two(struct hist_field *hist_field,
378 				struct tracing_map_elt *elt,
379 				struct trace_buffer *buffer,
380 				struct ring_buffer_event *rbe,
381 				void *event)
382 {
383 	struct hist_field *operand1 = hist_field->operands[0];
384 	struct hist_field *operand2 = hist_field->operands[1];
385 
386 	u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);
387 
388 	return div64_u64(val1, operand2->constant);
389 }
390 
391 static u64 div_by_mult_and_shift(struct hist_field *hist_field,
392 				struct tracing_map_elt *elt,
393 				struct trace_buffer *buffer,
394 				struct ring_buffer_event *rbe,
395 				void *event)
396 {
397 	struct hist_field *operand1 = hist_field->operands[0];
398 	struct hist_field *operand2 = hist_field->operands[1];
399 
400 	u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);
401 
402 	/*
403 	 * If the divisor is a constant, do a multiplication and shift instead.
404 	 *
405 	 * Choose Z = some power of 2. If Y <= Z, then:
406 	 *     X / Y = (X * (Z / Y)) / Z
407 	 *
408 	 * (Z / Y) is a constant (mult) which is calculated at parse time, so:
409 	 *     X / Y = (X * mult) / Z
410 	 *
411 	 * The division by Z can be replaced by a shift since Z is a power of 2:
412 	 *     X / Y = (X * mult) >> HIST_DIV_SHIFT
413 	 *
414 	 * As long, as X < Z the results will not be off by more than 1.
415 	 */
416 	if (val1 < (1 << HIST_DIV_SHIFT)) {
417 		u64 mult = operand2->div_multiplier;
418 
419 		return (val1 * mult + ((1 << HIST_DIV_SHIFT) - 1)) >> HIST_DIV_SHIFT;
420 	}
421 
422 	return div64_u64(val1, operand2->constant);
423 }
424 
425 static u64 hist_field_mult(struct hist_field *hist_field,
426 			   struct tracing_map_elt *elt,
427 			   struct trace_buffer *buffer,
428 			   struct ring_buffer_event *rbe,
429 			   void *event)
430 {
431 	struct hist_field *operand1 = hist_field->operands[0];
432 	struct hist_field *operand2 = hist_field->operands[1];
433 
434 	u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);
435 	u64 val2 = hist_fn_call(operand2, elt, buffer, rbe, event);
436 
437 	return val1 * val2;
438 }
439 
440 static u64 hist_field_unary_minus(struct hist_field *hist_field,
441 				  struct tracing_map_elt *elt,
442 				  struct trace_buffer *buffer,
443 				  struct ring_buffer_event *rbe,
444 				  void *event)
445 {
446 	struct hist_field *operand = hist_field->operands[0];
447 
448 	s64 sval = (s64)hist_fn_call(operand, elt, buffer, rbe, event);
449 	u64 val = (u64)-sval;
450 
451 	return val;
452 }
453 
454 #define DEFINE_HIST_FIELD_FN(type)					\
455 	static u64 hist_field_##type(struct hist_field *hist_field,	\
456 				     struct tracing_map_elt *elt,	\
457 				     struct trace_buffer *buffer,	\
458 				     struct ring_buffer_event *rbe,	\
459 				     void *event)			\
460 {									\
461 	type *addr = (type *)(event + hist_field->field->offset);	\
462 									\
463 	return (u64)(unsigned long)*addr;				\
464 }
465 
466 DEFINE_HIST_FIELD_FN(s64);
467 DEFINE_HIST_FIELD_FN(u64);
468 DEFINE_HIST_FIELD_FN(s32);
469 DEFINE_HIST_FIELD_FN(u32);
470 DEFINE_HIST_FIELD_FN(s16);
471 DEFINE_HIST_FIELD_FN(u16);
472 DEFINE_HIST_FIELD_FN(s8);
473 DEFINE_HIST_FIELD_FN(u8);
474 
475 #define for_each_hist_field(i, hist_data)	\
476 	for ((i) = 0; (i) < (hist_data)->n_fields; (i)++)
477 
478 #define for_each_hist_val_field(i, hist_data)	\
479 	for ((i) = 0; (i) < (hist_data)->n_vals; (i)++)
480 
481 #define for_each_hist_key_field(i, hist_data)	\
482 	for ((i) = (hist_data)->n_vals; (i) < (hist_data)->n_fields; (i)++)
483 
484 #define HITCOUNT_IDX		0
485 #define HIST_KEY_SIZE_MAX	(MAX_FILTER_STR_VAL + HIST_STACKTRACE_SIZE)
486 
487 enum hist_field_flags {
488 	HIST_FIELD_FL_HITCOUNT		= 1 << 0,
489 	HIST_FIELD_FL_KEY		= 1 << 1,
490 	HIST_FIELD_FL_STRING		= 1 << 2,
491 	HIST_FIELD_FL_HEX		= 1 << 3,
492 	HIST_FIELD_FL_SYM		= 1 << 4,
493 	HIST_FIELD_FL_SYM_OFFSET	= 1 << 5,
494 	HIST_FIELD_FL_EXECNAME		= 1 << 6,
495 	HIST_FIELD_FL_SYSCALL		= 1 << 7,
496 	HIST_FIELD_FL_STACKTRACE	= 1 << 8,
497 	HIST_FIELD_FL_LOG2		= 1 << 9,
498 	HIST_FIELD_FL_TIMESTAMP		= 1 << 10,
499 	HIST_FIELD_FL_TIMESTAMP_USECS	= 1 << 11,
500 	HIST_FIELD_FL_VAR		= 1 << 12,
501 	HIST_FIELD_FL_EXPR		= 1 << 13,
502 	HIST_FIELD_FL_VAR_REF		= 1 << 14,
503 	HIST_FIELD_FL_CPU		= 1 << 15,
504 	HIST_FIELD_FL_ALIAS		= 1 << 16,
505 	HIST_FIELD_FL_BUCKET		= 1 << 17,
506 	HIST_FIELD_FL_CONST		= 1 << 18,
507 	HIST_FIELD_FL_PERCENT		= 1 << 19,
508 	HIST_FIELD_FL_GRAPH		= 1 << 20,
509 };
510 
511 struct var_defs {
512 	unsigned int	n_vars;
513 	char		*name[TRACING_MAP_VARS_MAX];
514 	char		*expr[TRACING_MAP_VARS_MAX];
515 };
516 
517 struct hist_trigger_attrs {
518 	char		*keys_str;
519 	char		*vals_str;
520 	char		*sort_key_str;
521 	char		*name;
522 	char		*clock;
523 	bool		pause;
524 	bool		cont;
525 	bool		clear;
526 	bool		ts_in_usecs;
527 	bool		no_hitcount;
528 	unsigned int	map_bits;
529 
530 	char		*assignment_str[TRACING_MAP_VARS_MAX];
531 	unsigned int	n_assignments;
532 
533 	char		*action_str[HIST_ACTIONS_MAX];
534 	unsigned int	n_actions;
535 
536 	struct var_defs	var_defs;
537 };
538 
539 struct field_var {
540 	struct hist_field	*var;
541 	struct hist_field	*val;
542 };
543 
544 struct field_var_hist {
545 	struct hist_trigger_data	*hist_data;
546 	char				*cmd;
547 };
548 
549 struct hist_trigger_data {
550 	struct hist_field               *fields[HIST_FIELDS_MAX];
551 	unsigned int			n_vals;
552 	unsigned int			n_keys;
553 	unsigned int			n_fields;
554 	unsigned int			n_vars;
555 	unsigned int			n_var_str;
556 	unsigned int			key_size;
557 	struct tracing_map_sort_key	sort_keys[TRACING_MAP_SORT_KEYS_MAX];
558 	unsigned int			n_sort_keys;
559 	struct trace_event_file		*event_file;
560 	struct hist_trigger_attrs	*attrs;
561 	struct tracing_map		*map;
562 	bool				enable_timestamps;
563 	bool				remove;
564 	struct hist_field               *var_refs[TRACING_MAP_VARS_MAX];
565 	unsigned int			n_var_refs;
566 
567 	struct action_data		*actions[HIST_ACTIONS_MAX];
568 	unsigned int			n_actions;
569 
570 	struct field_var		*field_vars[SYNTH_FIELDS_MAX];
571 	unsigned int			n_field_vars;
572 	unsigned int			n_field_var_str;
573 	struct field_var_hist		*field_var_hists[SYNTH_FIELDS_MAX];
574 	unsigned int			n_field_var_hists;
575 
576 	struct field_var		*save_vars[SYNTH_FIELDS_MAX];
577 	unsigned int			n_save_vars;
578 	unsigned int			n_save_var_str;
579 };
580 
581 struct action_data;
582 
583 typedef void (*action_fn_t) (struct hist_trigger_data *hist_data,
584 			     struct tracing_map_elt *elt,
585 			     struct trace_buffer *buffer, void *rec,
586 			     struct ring_buffer_event *rbe, void *key,
587 			     struct action_data *data, u64 *var_ref_vals);
588 
589 typedef bool (*check_track_val_fn_t) (u64 track_val, u64 var_val);
590 
591 enum handler_id {
592 	HANDLER_ONMATCH = 1,
593 	HANDLER_ONMAX,
594 	HANDLER_ONCHANGE,
595 };
596 
597 enum action_id {
598 	ACTION_SAVE = 1,
599 	ACTION_TRACE,
600 	ACTION_SNAPSHOT,
601 };
602 
603 struct action_data {
604 	enum handler_id		handler;
605 	enum action_id		action;
606 	char			*action_name;
607 	action_fn_t		fn;
608 
609 	unsigned int		n_params;
610 	char			*params[SYNTH_FIELDS_MAX];
611 
612 	/*
613 	 * When a histogram trigger is hit, the values of any
614 	 * references to variables, including variables being passed
615 	 * as parameters to synthetic events, are collected into a
616 	 * var_ref_vals array.  This var_ref_idx array is an array of
617 	 * indices into the var_ref_vals array, one for each synthetic
618 	 * event param, and is passed to the synthetic event
619 	 * invocation.
620 	 */
621 	unsigned int		var_ref_idx[SYNTH_FIELDS_MAX];
622 	struct synth_event	*synth_event;
623 	bool			use_trace_keyword;
624 	char			*synth_event_name;
625 
626 	union {
627 		struct {
628 			char			*event;
629 			char			*event_system;
630 		} match_data;
631 
632 		struct {
633 			/*
634 			 * var_str contains the $-unstripped variable
635 			 * name referenced by var_ref, and used when
636 			 * printing the action.  Because var_ref
637 			 * creation is deferred to create_actions(),
638 			 * we need a per-action way to save it until
639 			 * then, thus var_str.
640 			 */
641 			char			*var_str;
642 
643 			/*
644 			 * var_ref refers to the variable being
645 			 * tracked e.g onmax($var).
646 			 */
647 			struct hist_field	*var_ref;
648 
649 			/*
650 			 * track_var contains the 'invisible' tracking
651 			 * variable created to keep the current
652 			 * e.g. max value.
653 			 */
654 			struct hist_field	*track_var;
655 
656 			check_track_val_fn_t	check_val;
657 			action_fn_t		save_data;
658 		} track_data;
659 	};
660 };
661 
662 struct track_data {
663 	u64				track_val;
664 	bool				updated;
665 
666 	unsigned int			key_len;
667 	void				*key;
668 	struct tracing_map_elt		elt;
669 
670 	struct action_data		*action_data;
671 	struct hist_trigger_data	*hist_data;
672 };
673 
674 struct hist_elt_data {
675 	char *comm;
676 	u64 *var_ref_vals;
677 	char **field_var_str;
678 	int n_field_var_str;
679 };
680 
681 struct snapshot_context {
682 	struct tracing_map_elt	*elt;
683 	void			*key;
684 };
685 
686 /*
687  * Returns the specific division function to use if the divisor
688  * is constant. This avoids extra branches when the trigger is hit.
689  */
690 static enum hist_field_fn hist_field_get_div_fn(struct hist_field *divisor)
691 {
692 	u64 div = divisor->constant;
693 
694 	if (!(div & (div - 1)))
695 		return HIST_FIELD_FN_DIV_POWER2;
696 
697 	/* If the divisor is too large, do a regular division */
698 	if (div > (1 << HIST_DIV_SHIFT))
699 		return HIST_FIELD_FN_DIV_NOT_POWER2;
700 
701 	divisor->div_multiplier = div64_u64((u64)(1 << HIST_DIV_SHIFT), div);
702 	return HIST_FIELD_FN_DIV_MULT_SHIFT;
703 }
704 
705 static void track_data_free(struct track_data *track_data)
706 {
707 	struct hist_elt_data *elt_data;
708 
709 	if (!track_data)
710 		return;
711 
712 	kfree(track_data->key);
713 
714 	elt_data = track_data->elt.private_data;
715 	if (elt_data) {
716 		kfree(elt_data->comm);
717 		kfree(elt_data);
718 	}
719 
720 	kfree(track_data);
721 }
722 
723 static struct track_data *track_data_alloc(unsigned int key_len,
724 					   struct action_data *action_data,
725 					   struct hist_trigger_data *hist_data)
726 {
727 	struct track_data *data = kzalloc(sizeof(*data), GFP_KERNEL);
728 	struct hist_elt_data *elt_data;
729 
730 	if (!data)
731 		return ERR_PTR(-ENOMEM);
732 
733 	data->key = kzalloc(key_len, GFP_KERNEL);
734 	if (!data->key) {
735 		track_data_free(data);
736 		return ERR_PTR(-ENOMEM);
737 	}
738 
739 	data->key_len = key_len;
740 	data->action_data = action_data;
741 	data->hist_data = hist_data;
742 
743 	elt_data = kzalloc(sizeof(*elt_data), GFP_KERNEL);
744 	if (!elt_data) {
745 		track_data_free(data);
746 		return ERR_PTR(-ENOMEM);
747 	}
748 
749 	data->elt.private_data = elt_data;
750 
751 	elt_data->comm = kzalloc(TASK_COMM_LEN, GFP_KERNEL);
752 	if (!elt_data->comm) {
753 		track_data_free(data);
754 		return ERR_PTR(-ENOMEM);
755 	}
756 
757 	return data;
758 }
759 
760 #define HIST_PREFIX "hist:"
761 
762 static char *last_cmd;
763 static char last_cmd_loc[MAX_FILTER_STR_VAL];
764 
765 static int errpos(char *str)
766 {
767 	if (!str || !last_cmd)
768 		return 0;
769 
770 	return err_pos(last_cmd, str);
771 }
772 
773 static void last_cmd_set(struct trace_event_file *file, char *str)
774 {
775 	const char *system = NULL, *name = NULL;
776 	struct trace_event_call *call;
777 	int len;
778 
779 	if (!str)
780 		return;
781 
782 	/* sizeof() contains the nul byte */
783 	len = sizeof(HIST_PREFIX) + strlen(str);
784 	kfree(last_cmd);
785 	last_cmd = kzalloc(len, GFP_KERNEL);
786 	if (!last_cmd)
787 		return;
788 
789 	strcpy(last_cmd, HIST_PREFIX);
790 	/* Again, sizeof() contains the nul byte */
791 	len -= sizeof(HIST_PREFIX);
792 	strncat(last_cmd, str, len);
793 
794 	if (file) {
795 		call = file->event_call;
796 		system = call->class->system;
797 		if (system) {
798 			name = trace_event_name(call);
799 			if (!name)
800 				system = NULL;
801 		}
802 	}
803 
804 	if (system)
805 		snprintf(last_cmd_loc, MAX_FILTER_STR_VAL, HIST_PREFIX "%s:%s", system, name);
806 }
807 
808 static void hist_err(struct trace_array *tr, u8 err_type, u16 err_pos)
809 {
810 	if (!last_cmd)
811 		return;
812 
813 	tracing_log_err(tr, last_cmd_loc, last_cmd, err_text,
814 			err_type, err_pos);
815 }
816 
817 static void hist_err_clear(void)
818 {
819 	if (last_cmd)
820 		last_cmd[0] = '\0';
821 	last_cmd_loc[0] = '\0';
822 }
823 
824 typedef void (*synth_probe_func_t) (void *__data, u64 *var_ref_vals,
825 				    unsigned int *var_ref_idx);
826 
827 static inline void trace_synth(struct synth_event *event, u64 *var_ref_vals,
828 			       unsigned int *var_ref_idx)
829 {
830 	struct tracepoint *tp = event->tp;
831 
832 	if (unlikely(atomic_read(&tp->key.enabled) > 0)) {
833 		struct tracepoint_func *probe_func_ptr;
834 		synth_probe_func_t probe_func;
835 		void *__data;
836 
837 		if (!(cpu_online(raw_smp_processor_id())))
838 			return;
839 
840 		probe_func_ptr = rcu_dereference_sched((tp)->funcs);
841 		if (probe_func_ptr) {
842 			do {
843 				probe_func = probe_func_ptr->func;
844 				__data = probe_func_ptr->data;
845 				probe_func(__data, var_ref_vals, var_ref_idx);
846 			} while ((++probe_func_ptr)->func);
847 		}
848 	}
849 }
850 
851 static void action_trace(struct hist_trigger_data *hist_data,
852 			 struct tracing_map_elt *elt,
853 			 struct trace_buffer *buffer, void *rec,
854 			 struct ring_buffer_event *rbe, void *key,
855 			 struct action_data *data, u64 *var_ref_vals)
856 {
857 	struct synth_event *event = data->synth_event;
858 
859 	trace_synth(event, var_ref_vals, data->var_ref_idx);
860 }
861 
862 struct hist_var_data {
863 	struct list_head list;
864 	struct hist_trigger_data *hist_data;
865 };
866 
867 static u64 hist_field_timestamp(struct hist_field *hist_field,
868 				struct tracing_map_elt *elt,
869 				struct trace_buffer *buffer,
870 				struct ring_buffer_event *rbe,
871 				void *event)
872 {
873 	struct hist_trigger_data *hist_data = hist_field->hist_data;
874 	struct trace_array *tr = hist_data->event_file->tr;
875 
876 	u64 ts = ring_buffer_event_time_stamp(buffer, rbe);
877 
878 	if (hist_data->attrs->ts_in_usecs && trace_clock_in_ns(tr))
879 		ts = ns2usecs(ts);
880 
881 	return ts;
882 }
883 
884 static u64 hist_field_cpu(struct hist_field *hist_field,
885 			  struct tracing_map_elt *elt,
886 			  struct trace_buffer *buffer,
887 			  struct ring_buffer_event *rbe,
888 			  void *event)
889 {
890 	int cpu = smp_processor_id();
891 
892 	return cpu;
893 }
894 
895 /**
896  * check_field_for_var_ref - Check if a VAR_REF field references a variable
897  * @hist_field: The VAR_REF field to check
898  * @var_data: The hist trigger that owns the variable
899  * @var_idx: The trigger variable identifier
900  *
901  * Check the given VAR_REF field to see whether or not it references
902  * the given variable associated with the given trigger.
903  *
904  * Return: The VAR_REF field if it does reference the variable, NULL if not
905  */
906 static struct hist_field *
907 check_field_for_var_ref(struct hist_field *hist_field,
908 			struct hist_trigger_data *var_data,
909 			unsigned int var_idx)
910 {
911 	WARN_ON(!(hist_field && hist_field->flags & HIST_FIELD_FL_VAR_REF));
912 
913 	if (hist_field && hist_field->var.idx == var_idx &&
914 	    hist_field->var.hist_data == var_data)
915 		return hist_field;
916 
917 	return NULL;
918 }
919 
920 /**
921  * find_var_ref - Check if a trigger has a reference to a trigger variable
922  * @hist_data: The hist trigger that might have a reference to the variable
923  * @var_data: The hist trigger that owns the variable
924  * @var_idx: The trigger variable identifier
925  *
926  * Check the list of var_refs[] on the first hist trigger to see
927  * whether any of them are references to the variable on the second
928  * trigger.
929  *
930  * Return: The VAR_REF field referencing the variable if so, NULL if not
931  */
932 static struct hist_field *find_var_ref(struct hist_trigger_data *hist_data,
933 				       struct hist_trigger_data *var_data,
934 				       unsigned int var_idx)
935 {
936 	struct hist_field *hist_field;
937 	unsigned int i;
938 
939 	for (i = 0; i < hist_data->n_var_refs; i++) {
940 		hist_field = hist_data->var_refs[i];
941 		if (check_field_for_var_ref(hist_field, var_data, var_idx))
942 			return hist_field;
943 	}
944 
945 	return NULL;
946 }
947 
948 /**
949  * find_any_var_ref - Check if there is a reference to a given trigger variable
950  * @hist_data: The hist trigger
951  * @var_idx: The trigger variable identifier
952  *
953  * Check to see whether the given variable is currently referenced by
954  * any other trigger.
955  *
956  * The trigger the variable is defined on is explicitly excluded - the
957  * assumption being that a self-reference doesn't prevent a trigger
958  * from being removed.
959  *
960  * Return: The VAR_REF field referencing the variable if so, NULL if not
961  */
962 static struct hist_field *find_any_var_ref(struct hist_trigger_data *hist_data,
963 					   unsigned int var_idx)
964 {
965 	struct trace_array *tr = hist_data->event_file->tr;
966 	struct hist_field *found = NULL;
967 	struct hist_var_data *var_data;
968 
969 	list_for_each_entry(var_data, &tr->hist_vars, list) {
970 		if (var_data->hist_data == hist_data)
971 			continue;
972 		found = find_var_ref(var_data->hist_data, hist_data, var_idx);
973 		if (found)
974 			break;
975 	}
976 
977 	return found;
978 }
979 
980 /**
981  * check_var_refs - Check if there is a reference to any of trigger's variables
982  * @hist_data: The hist trigger
983  *
984  * A trigger can define one or more variables.  If any one of them is
985  * currently referenced by any other trigger, this function will
986  * determine that.
987  *
988  * Typically used to determine whether or not a trigger can be removed
989  * - if there are any references to a trigger's variables, it cannot.
990  *
991  * Return: True if there is a reference to any of trigger's variables
992  */
993 static bool check_var_refs(struct hist_trigger_data *hist_data)
994 {
995 	struct hist_field *field;
996 	bool found = false;
997 	int i;
998 
999 	for_each_hist_field(i, hist_data) {
1000 		field = hist_data->fields[i];
1001 		if (field && field->flags & HIST_FIELD_FL_VAR) {
1002 			if (find_any_var_ref(hist_data, field->var.idx)) {
1003 				found = true;
1004 				break;
1005 			}
1006 		}
1007 	}
1008 
1009 	return found;
1010 }
1011 
1012 static struct hist_var_data *find_hist_vars(struct hist_trigger_data *hist_data)
1013 {
1014 	struct trace_array *tr = hist_data->event_file->tr;
1015 	struct hist_var_data *var_data, *found = NULL;
1016 
1017 	list_for_each_entry(var_data, &tr->hist_vars, list) {
1018 		if (var_data->hist_data == hist_data) {
1019 			found = var_data;
1020 			break;
1021 		}
1022 	}
1023 
1024 	return found;
1025 }
1026 
1027 static bool field_has_hist_vars(struct hist_field *hist_field,
1028 				unsigned int level)
1029 {
1030 	int i;
1031 
1032 	if (level > 3)
1033 		return false;
1034 
1035 	if (!hist_field)
1036 		return false;
1037 
1038 	if (hist_field->flags & HIST_FIELD_FL_VAR ||
1039 	    hist_field->flags & HIST_FIELD_FL_VAR_REF)
1040 		return true;
1041 
1042 	for (i = 0; i < HIST_FIELD_OPERANDS_MAX; i++) {
1043 		struct hist_field *operand;
1044 
1045 		operand = hist_field->operands[i];
1046 		if (field_has_hist_vars(operand, level + 1))
1047 			return true;
1048 	}
1049 
1050 	return false;
1051 }
1052 
1053 static bool has_hist_vars(struct hist_trigger_data *hist_data)
1054 {
1055 	struct hist_field *hist_field;
1056 	int i;
1057 
1058 	for_each_hist_field(i, hist_data) {
1059 		hist_field = hist_data->fields[i];
1060 		if (field_has_hist_vars(hist_field, 0))
1061 			return true;
1062 	}
1063 
1064 	return false;
1065 }
1066 
1067 static int save_hist_vars(struct hist_trigger_data *hist_data)
1068 {
1069 	struct trace_array *tr = hist_data->event_file->tr;
1070 	struct hist_var_data *var_data;
1071 
1072 	var_data = find_hist_vars(hist_data);
1073 	if (var_data)
1074 		return 0;
1075 
1076 	if (tracing_check_open_get_tr(tr))
1077 		return -ENODEV;
1078 
1079 	var_data = kzalloc(sizeof(*var_data), GFP_KERNEL);
1080 	if (!var_data) {
1081 		trace_array_put(tr);
1082 		return -ENOMEM;
1083 	}
1084 
1085 	var_data->hist_data = hist_data;
1086 	list_add(&var_data->list, &tr->hist_vars);
1087 
1088 	return 0;
1089 }
1090 
1091 static void remove_hist_vars(struct hist_trigger_data *hist_data)
1092 {
1093 	struct trace_array *tr = hist_data->event_file->tr;
1094 	struct hist_var_data *var_data;
1095 
1096 	var_data = find_hist_vars(hist_data);
1097 	if (!var_data)
1098 		return;
1099 
1100 	if (WARN_ON(check_var_refs(hist_data)))
1101 		return;
1102 
1103 	list_del(&var_data->list);
1104 
1105 	kfree(var_data);
1106 
1107 	trace_array_put(tr);
1108 }
1109 
1110 static struct hist_field *find_var_field(struct hist_trigger_data *hist_data,
1111 					 const char *var_name)
1112 {
1113 	struct hist_field *hist_field, *found = NULL;
1114 	int i;
1115 
1116 	for_each_hist_field(i, hist_data) {
1117 		hist_field = hist_data->fields[i];
1118 		if (hist_field && hist_field->flags & HIST_FIELD_FL_VAR &&
1119 		    strcmp(hist_field->var.name, var_name) == 0) {
1120 			found = hist_field;
1121 			break;
1122 		}
1123 	}
1124 
1125 	return found;
1126 }
1127 
1128 static struct hist_field *find_var(struct hist_trigger_data *hist_data,
1129 				   struct trace_event_file *file,
1130 				   const char *var_name)
1131 {
1132 	struct hist_trigger_data *test_data;
1133 	struct event_trigger_data *test;
1134 	struct hist_field *hist_field;
1135 
1136 	lockdep_assert_held(&event_mutex);
1137 
1138 	hist_field = find_var_field(hist_data, var_name);
1139 	if (hist_field)
1140 		return hist_field;
1141 
1142 	list_for_each_entry(test, &file->triggers, list) {
1143 		if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
1144 			test_data = test->private_data;
1145 			hist_field = find_var_field(test_data, var_name);
1146 			if (hist_field)
1147 				return hist_field;
1148 		}
1149 	}
1150 
1151 	return NULL;
1152 }
1153 
1154 static struct trace_event_file *find_var_file(struct trace_array *tr,
1155 					      char *system,
1156 					      char *event_name,
1157 					      char *var_name)
1158 {
1159 	struct hist_trigger_data *var_hist_data;
1160 	struct hist_var_data *var_data;
1161 	struct trace_event_file *file, *found = NULL;
1162 
1163 	if (system)
1164 		return find_event_file(tr, system, event_name);
1165 
1166 	list_for_each_entry(var_data, &tr->hist_vars, list) {
1167 		var_hist_data = var_data->hist_data;
1168 		file = var_hist_data->event_file;
1169 		if (file == found)
1170 			continue;
1171 
1172 		if (find_var_field(var_hist_data, var_name)) {
1173 			if (found) {
1174 				hist_err(tr, HIST_ERR_VAR_NOT_UNIQUE, errpos(var_name));
1175 				return NULL;
1176 			}
1177 
1178 			found = file;
1179 		}
1180 	}
1181 
1182 	return found;
1183 }
1184 
1185 static struct hist_field *find_file_var(struct trace_event_file *file,
1186 					const char *var_name)
1187 {
1188 	struct hist_trigger_data *test_data;
1189 	struct event_trigger_data *test;
1190 	struct hist_field *hist_field;
1191 
1192 	lockdep_assert_held(&event_mutex);
1193 
1194 	list_for_each_entry(test, &file->triggers, list) {
1195 		if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
1196 			test_data = test->private_data;
1197 			hist_field = find_var_field(test_data, var_name);
1198 			if (hist_field)
1199 				return hist_field;
1200 		}
1201 	}
1202 
1203 	return NULL;
1204 }
1205 
1206 static struct hist_field *
1207 find_match_var(struct hist_trigger_data *hist_data, char *var_name)
1208 {
1209 	struct trace_array *tr = hist_data->event_file->tr;
1210 	struct hist_field *hist_field, *found = NULL;
1211 	struct trace_event_file *file;
1212 	unsigned int i;
1213 
1214 	for (i = 0; i < hist_data->n_actions; i++) {
1215 		struct action_data *data = hist_data->actions[i];
1216 
1217 		if (data->handler == HANDLER_ONMATCH) {
1218 			char *system = data->match_data.event_system;
1219 			char *event_name = data->match_data.event;
1220 
1221 			file = find_var_file(tr, system, event_name, var_name);
1222 			if (!file)
1223 				continue;
1224 			hist_field = find_file_var(file, var_name);
1225 			if (hist_field) {
1226 				if (found) {
1227 					hist_err(tr, HIST_ERR_VAR_NOT_UNIQUE,
1228 						 errpos(var_name));
1229 					return ERR_PTR(-EINVAL);
1230 				}
1231 
1232 				found = hist_field;
1233 			}
1234 		}
1235 	}
1236 	return found;
1237 }
1238 
1239 static struct hist_field *find_event_var(struct hist_trigger_data *hist_data,
1240 					 char *system,
1241 					 char *event_name,
1242 					 char *var_name)
1243 {
1244 	struct trace_array *tr = hist_data->event_file->tr;
1245 	struct hist_field *hist_field = NULL;
1246 	struct trace_event_file *file;
1247 
1248 	if (!system || !event_name) {
1249 		hist_field = find_match_var(hist_data, var_name);
1250 		if (IS_ERR(hist_field))
1251 			return NULL;
1252 		if (hist_field)
1253 			return hist_field;
1254 	}
1255 
1256 	file = find_var_file(tr, system, event_name, var_name);
1257 	if (!file)
1258 		return NULL;
1259 
1260 	hist_field = find_file_var(file, var_name);
1261 
1262 	return hist_field;
1263 }
1264 
1265 static u64 hist_field_var_ref(struct hist_field *hist_field,
1266 			      struct tracing_map_elt *elt,
1267 			      struct trace_buffer *buffer,
1268 			      struct ring_buffer_event *rbe,
1269 			      void *event)
1270 {
1271 	struct hist_elt_data *elt_data;
1272 	u64 var_val = 0;
1273 
1274 	if (WARN_ON_ONCE(!elt))
1275 		return var_val;
1276 
1277 	elt_data = elt->private_data;
1278 	var_val = elt_data->var_ref_vals[hist_field->var_ref_idx];
1279 
1280 	return var_val;
1281 }
1282 
1283 static bool resolve_var_refs(struct hist_trigger_data *hist_data, void *key,
1284 			     u64 *var_ref_vals, bool self)
1285 {
1286 	struct hist_trigger_data *var_data;
1287 	struct tracing_map_elt *var_elt;
1288 	struct hist_field *hist_field;
1289 	unsigned int i, var_idx;
1290 	bool resolved = true;
1291 	u64 var_val = 0;
1292 
1293 	for (i = 0; i < hist_data->n_var_refs; i++) {
1294 		hist_field = hist_data->var_refs[i];
1295 		var_idx = hist_field->var.idx;
1296 		var_data = hist_field->var.hist_data;
1297 
1298 		if (var_data == NULL) {
1299 			resolved = false;
1300 			break;
1301 		}
1302 
1303 		if ((self && var_data != hist_data) ||
1304 		    (!self && var_data == hist_data))
1305 			continue;
1306 
1307 		var_elt = tracing_map_lookup(var_data->map, key);
1308 		if (!var_elt) {
1309 			resolved = false;
1310 			break;
1311 		}
1312 
1313 		if (!tracing_map_var_set(var_elt, var_idx)) {
1314 			resolved = false;
1315 			break;
1316 		}
1317 
1318 		if (self || !hist_field->read_once)
1319 			var_val = tracing_map_read_var(var_elt, var_idx);
1320 		else
1321 			var_val = tracing_map_read_var_once(var_elt, var_idx);
1322 
1323 		var_ref_vals[i] = var_val;
1324 	}
1325 
1326 	return resolved;
1327 }
1328 
1329 static const char *hist_field_name(struct hist_field *field,
1330 				   unsigned int level)
1331 {
1332 	const char *field_name = "";
1333 
1334 	if (WARN_ON_ONCE(!field))
1335 		return field_name;
1336 
1337 	if (level > 1)
1338 		return field_name;
1339 
1340 	if (field->field)
1341 		field_name = field->field->name;
1342 	else if (field->flags & HIST_FIELD_FL_LOG2 ||
1343 		 field->flags & HIST_FIELD_FL_ALIAS ||
1344 		 field->flags & HIST_FIELD_FL_BUCKET)
1345 		field_name = hist_field_name(field->operands[0], ++level);
1346 	else if (field->flags & HIST_FIELD_FL_CPU)
1347 		field_name = "common_cpu";
1348 	else if (field->flags & HIST_FIELD_FL_EXPR ||
1349 		 field->flags & HIST_FIELD_FL_VAR_REF) {
1350 		if (field->system) {
1351 			static char full_name[MAX_FILTER_STR_VAL];
1352 
1353 			strcat(full_name, field->system);
1354 			strcat(full_name, ".");
1355 			strcat(full_name, field->event_name);
1356 			strcat(full_name, ".");
1357 			strcat(full_name, field->name);
1358 			field_name = full_name;
1359 		} else
1360 			field_name = field->name;
1361 	} else if (field->flags & HIST_FIELD_FL_TIMESTAMP)
1362 		field_name = "common_timestamp";
1363 	else if (field->flags & HIST_FIELD_FL_STACKTRACE) {
1364 		if (field->field)
1365 			field_name = field->field->name;
1366 		else
1367 			field_name = "common_stacktrace";
1368 	} else if (field->flags & HIST_FIELD_FL_HITCOUNT)
1369 		field_name = "hitcount";
1370 
1371 	if (field_name == NULL)
1372 		field_name = "";
1373 
1374 	return field_name;
1375 }
1376 
1377 static enum hist_field_fn select_value_fn(int field_size, int field_is_signed)
1378 {
1379 	switch (field_size) {
1380 	case 8:
1381 		if (field_is_signed)
1382 			return HIST_FIELD_FN_S64;
1383 		else
1384 			return HIST_FIELD_FN_U64;
1385 	case 4:
1386 		if (field_is_signed)
1387 			return HIST_FIELD_FN_S32;
1388 		else
1389 			return HIST_FIELD_FN_U32;
1390 	case 2:
1391 		if (field_is_signed)
1392 			return HIST_FIELD_FN_S16;
1393 		else
1394 			return HIST_FIELD_FN_U16;
1395 	case 1:
1396 		if (field_is_signed)
1397 			return HIST_FIELD_FN_S8;
1398 		else
1399 			return HIST_FIELD_FN_U8;
1400 	}
1401 
1402 	return HIST_FIELD_FN_NOP;
1403 }
1404 
1405 static int parse_map_size(char *str)
1406 {
1407 	unsigned long size, map_bits;
1408 	int ret;
1409 
1410 	ret = kstrtoul(str, 0, &size);
1411 	if (ret)
1412 		goto out;
1413 
1414 	map_bits = ilog2(roundup_pow_of_two(size));
1415 	if (map_bits < TRACING_MAP_BITS_MIN ||
1416 	    map_bits > TRACING_MAP_BITS_MAX)
1417 		ret = -EINVAL;
1418 	else
1419 		ret = map_bits;
1420  out:
1421 	return ret;
1422 }
1423 
1424 static void destroy_hist_trigger_attrs(struct hist_trigger_attrs *attrs)
1425 {
1426 	unsigned int i;
1427 
1428 	if (!attrs)
1429 		return;
1430 
1431 	for (i = 0; i < attrs->n_assignments; i++)
1432 		kfree(attrs->assignment_str[i]);
1433 
1434 	for (i = 0; i < attrs->n_actions; i++)
1435 		kfree(attrs->action_str[i]);
1436 
1437 	kfree(attrs->name);
1438 	kfree(attrs->sort_key_str);
1439 	kfree(attrs->keys_str);
1440 	kfree(attrs->vals_str);
1441 	kfree(attrs->clock);
1442 	kfree(attrs);
1443 }
1444 
1445 static int parse_action(char *str, struct hist_trigger_attrs *attrs)
1446 {
1447 	int ret = -EINVAL;
1448 
1449 	if (attrs->n_actions >= HIST_ACTIONS_MAX)
1450 		return ret;
1451 
1452 	if ((str_has_prefix(str, "onmatch(")) ||
1453 	    (str_has_prefix(str, "onmax(")) ||
1454 	    (str_has_prefix(str, "onchange("))) {
1455 		attrs->action_str[attrs->n_actions] = kstrdup(str, GFP_KERNEL);
1456 		if (!attrs->action_str[attrs->n_actions]) {
1457 			ret = -ENOMEM;
1458 			return ret;
1459 		}
1460 		attrs->n_actions++;
1461 		ret = 0;
1462 	}
1463 	return ret;
1464 }
1465 
1466 static int parse_assignment(struct trace_array *tr,
1467 			    char *str, struct hist_trigger_attrs *attrs)
1468 {
1469 	int len, ret = 0;
1470 
1471 	if ((len = str_has_prefix(str, "key=")) ||
1472 	    (len = str_has_prefix(str, "keys="))) {
1473 		attrs->keys_str = kstrdup(str + len, GFP_KERNEL);
1474 		if (!attrs->keys_str) {
1475 			ret = -ENOMEM;
1476 			goto out;
1477 		}
1478 	} else if ((len = str_has_prefix(str, "val=")) ||
1479 		   (len = str_has_prefix(str, "vals=")) ||
1480 		   (len = str_has_prefix(str, "values="))) {
1481 		attrs->vals_str = kstrdup(str + len, GFP_KERNEL);
1482 		if (!attrs->vals_str) {
1483 			ret = -ENOMEM;
1484 			goto out;
1485 		}
1486 	} else if ((len = str_has_prefix(str, "sort="))) {
1487 		attrs->sort_key_str = kstrdup(str + len, GFP_KERNEL);
1488 		if (!attrs->sort_key_str) {
1489 			ret = -ENOMEM;
1490 			goto out;
1491 		}
1492 	} else if (str_has_prefix(str, "name=")) {
1493 		attrs->name = kstrdup(str, GFP_KERNEL);
1494 		if (!attrs->name) {
1495 			ret = -ENOMEM;
1496 			goto out;
1497 		}
1498 	} else if ((len = str_has_prefix(str, "clock="))) {
1499 		str += len;
1500 
1501 		str = strstrip(str);
1502 		attrs->clock = kstrdup(str, GFP_KERNEL);
1503 		if (!attrs->clock) {
1504 			ret = -ENOMEM;
1505 			goto out;
1506 		}
1507 	} else if ((len = str_has_prefix(str, "size="))) {
1508 		int map_bits = parse_map_size(str + len);
1509 
1510 		if (map_bits < 0) {
1511 			ret = map_bits;
1512 			goto out;
1513 		}
1514 		attrs->map_bits = map_bits;
1515 	} else {
1516 		char *assignment;
1517 
1518 		if (attrs->n_assignments == TRACING_MAP_VARS_MAX) {
1519 			hist_err(tr, HIST_ERR_TOO_MANY_VARS, errpos(str));
1520 			ret = -EINVAL;
1521 			goto out;
1522 		}
1523 
1524 		assignment = kstrdup(str, GFP_KERNEL);
1525 		if (!assignment) {
1526 			ret = -ENOMEM;
1527 			goto out;
1528 		}
1529 
1530 		attrs->assignment_str[attrs->n_assignments++] = assignment;
1531 	}
1532  out:
1533 	return ret;
1534 }
1535 
1536 static struct hist_trigger_attrs *
1537 parse_hist_trigger_attrs(struct trace_array *tr, char *trigger_str)
1538 {
1539 	struct hist_trigger_attrs *attrs;
1540 	int ret = 0;
1541 
1542 	attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1543 	if (!attrs)
1544 		return ERR_PTR(-ENOMEM);
1545 
1546 	while (trigger_str) {
1547 		char *str = strsep(&trigger_str, ":");
1548 		char *rhs;
1549 
1550 		rhs = strchr(str, '=');
1551 		if (rhs) {
1552 			if (!strlen(++rhs)) {
1553 				ret = -EINVAL;
1554 				hist_err(tr, HIST_ERR_EMPTY_ASSIGNMENT, errpos(str));
1555 				goto free;
1556 			}
1557 			ret = parse_assignment(tr, str, attrs);
1558 			if (ret)
1559 				goto free;
1560 		} else if (strcmp(str, "nohitcount") == 0 ||
1561 			   strcmp(str, "NOHC") == 0)
1562 			attrs->no_hitcount = true;
1563 		else if (strcmp(str, "pause") == 0)
1564 			attrs->pause = true;
1565 		else if ((strcmp(str, "cont") == 0) ||
1566 			 (strcmp(str, "continue") == 0))
1567 			attrs->cont = true;
1568 		else if (strcmp(str, "clear") == 0)
1569 			attrs->clear = true;
1570 		else {
1571 			ret = parse_action(str, attrs);
1572 			if (ret)
1573 				goto free;
1574 		}
1575 	}
1576 
1577 	if (!attrs->keys_str) {
1578 		ret = -EINVAL;
1579 		goto free;
1580 	}
1581 
1582 	if (!attrs->clock) {
1583 		attrs->clock = kstrdup("global", GFP_KERNEL);
1584 		if (!attrs->clock) {
1585 			ret = -ENOMEM;
1586 			goto free;
1587 		}
1588 	}
1589 
1590 	return attrs;
1591  free:
1592 	destroy_hist_trigger_attrs(attrs);
1593 
1594 	return ERR_PTR(ret);
1595 }
1596 
1597 static inline void save_comm(char *comm, struct task_struct *task)
1598 {
1599 	if (!task->pid) {
1600 		strcpy(comm, "<idle>");
1601 		return;
1602 	}
1603 
1604 	if (WARN_ON_ONCE(task->pid < 0)) {
1605 		strcpy(comm, "<XXX>");
1606 		return;
1607 	}
1608 
1609 	strncpy(comm, task->comm, TASK_COMM_LEN);
1610 }
1611 
1612 static void hist_elt_data_free(struct hist_elt_data *elt_data)
1613 {
1614 	unsigned int i;
1615 
1616 	for (i = 0; i < elt_data->n_field_var_str; i++)
1617 		kfree(elt_data->field_var_str[i]);
1618 
1619 	kfree(elt_data->field_var_str);
1620 
1621 	kfree(elt_data->comm);
1622 	kfree(elt_data);
1623 }
1624 
1625 static void hist_trigger_elt_data_free(struct tracing_map_elt *elt)
1626 {
1627 	struct hist_elt_data *elt_data = elt->private_data;
1628 
1629 	hist_elt_data_free(elt_data);
1630 }
1631 
1632 static int hist_trigger_elt_data_alloc(struct tracing_map_elt *elt)
1633 {
1634 	struct hist_trigger_data *hist_data = elt->map->private_data;
1635 	unsigned int size = TASK_COMM_LEN;
1636 	struct hist_elt_data *elt_data;
1637 	struct hist_field *hist_field;
1638 	unsigned int i, n_str;
1639 
1640 	elt_data = kzalloc(sizeof(*elt_data), GFP_KERNEL);
1641 	if (!elt_data)
1642 		return -ENOMEM;
1643 
1644 	for_each_hist_field(i, hist_data) {
1645 		hist_field = hist_data->fields[i];
1646 
1647 		if (hist_field->flags & HIST_FIELD_FL_EXECNAME) {
1648 			elt_data->comm = kzalloc(size, GFP_KERNEL);
1649 			if (!elt_data->comm) {
1650 				kfree(elt_data);
1651 				return -ENOMEM;
1652 			}
1653 			break;
1654 		}
1655 	}
1656 
1657 	n_str = hist_data->n_field_var_str + hist_data->n_save_var_str +
1658 		hist_data->n_var_str;
1659 	if (n_str > SYNTH_FIELDS_MAX) {
1660 		hist_elt_data_free(elt_data);
1661 		return -EINVAL;
1662 	}
1663 
1664 	BUILD_BUG_ON(STR_VAR_LEN_MAX & (sizeof(u64) - 1));
1665 
1666 	size = STR_VAR_LEN_MAX;
1667 
1668 	elt_data->field_var_str = kcalloc(n_str, sizeof(char *), GFP_KERNEL);
1669 	if (!elt_data->field_var_str) {
1670 		hist_elt_data_free(elt_data);
1671 		return -EINVAL;
1672 	}
1673 	elt_data->n_field_var_str = n_str;
1674 
1675 	for (i = 0; i < n_str; i++) {
1676 		elt_data->field_var_str[i] = kzalloc(size, GFP_KERNEL);
1677 		if (!elt_data->field_var_str[i]) {
1678 			hist_elt_data_free(elt_data);
1679 			return -ENOMEM;
1680 		}
1681 	}
1682 
1683 	elt->private_data = elt_data;
1684 
1685 	return 0;
1686 }
1687 
1688 static void hist_trigger_elt_data_init(struct tracing_map_elt *elt)
1689 {
1690 	struct hist_elt_data *elt_data = elt->private_data;
1691 
1692 	if (elt_data->comm)
1693 		save_comm(elt_data->comm, current);
1694 }
1695 
1696 static const struct tracing_map_ops hist_trigger_elt_data_ops = {
1697 	.elt_alloc	= hist_trigger_elt_data_alloc,
1698 	.elt_free	= hist_trigger_elt_data_free,
1699 	.elt_init	= hist_trigger_elt_data_init,
1700 };
1701 
1702 static const char *get_hist_field_flags(struct hist_field *hist_field)
1703 {
1704 	const char *flags_str = NULL;
1705 
1706 	if (hist_field->flags & HIST_FIELD_FL_HEX)
1707 		flags_str = "hex";
1708 	else if (hist_field->flags & HIST_FIELD_FL_SYM)
1709 		flags_str = "sym";
1710 	else if (hist_field->flags & HIST_FIELD_FL_SYM_OFFSET)
1711 		flags_str = "sym-offset";
1712 	else if (hist_field->flags & HIST_FIELD_FL_EXECNAME)
1713 		flags_str = "execname";
1714 	else if (hist_field->flags & HIST_FIELD_FL_SYSCALL)
1715 		flags_str = "syscall";
1716 	else if (hist_field->flags & HIST_FIELD_FL_LOG2)
1717 		flags_str = "log2";
1718 	else if (hist_field->flags & HIST_FIELD_FL_BUCKET)
1719 		flags_str = "buckets";
1720 	else if (hist_field->flags & HIST_FIELD_FL_TIMESTAMP_USECS)
1721 		flags_str = "usecs";
1722 	else if (hist_field->flags & HIST_FIELD_FL_PERCENT)
1723 		flags_str = "percent";
1724 	else if (hist_field->flags & HIST_FIELD_FL_GRAPH)
1725 		flags_str = "graph";
1726 	else if (hist_field->flags & HIST_FIELD_FL_STACKTRACE)
1727 		flags_str = "stacktrace";
1728 
1729 	return flags_str;
1730 }
1731 
1732 static void expr_field_str(struct hist_field *field, char *expr)
1733 {
1734 	if (field->flags & HIST_FIELD_FL_VAR_REF)
1735 		strcat(expr, "$");
1736 	else if (field->flags & HIST_FIELD_FL_CONST) {
1737 		char str[HIST_CONST_DIGITS_MAX];
1738 
1739 		snprintf(str, HIST_CONST_DIGITS_MAX, "%llu", field->constant);
1740 		strcat(expr, str);
1741 	}
1742 
1743 	strcat(expr, hist_field_name(field, 0));
1744 
1745 	if (field->flags && !(field->flags & HIST_FIELD_FL_VAR_REF)) {
1746 		const char *flags_str = get_hist_field_flags(field);
1747 
1748 		if (flags_str) {
1749 			strcat(expr, ".");
1750 			strcat(expr, flags_str);
1751 		}
1752 	}
1753 }
1754 
1755 static char *expr_str(struct hist_field *field, unsigned int level)
1756 {
1757 	char *expr;
1758 
1759 	if (level > 1)
1760 		return NULL;
1761 
1762 	expr = kzalloc(MAX_FILTER_STR_VAL, GFP_KERNEL);
1763 	if (!expr)
1764 		return NULL;
1765 
1766 	if (!field->operands[0]) {
1767 		expr_field_str(field, expr);
1768 		return expr;
1769 	}
1770 
1771 	if (field->operator == FIELD_OP_UNARY_MINUS) {
1772 		char *subexpr;
1773 
1774 		strcat(expr, "-(");
1775 		subexpr = expr_str(field->operands[0], ++level);
1776 		if (!subexpr) {
1777 			kfree(expr);
1778 			return NULL;
1779 		}
1780 		strcat(expr, subexpr);
1781 		strcat(expr, ")");
1782 
1783 		kfree(subexpr);
1784 
1785 		return expr;
1786 	}
1787 
1788 	expr_field_str(field->operands[0], expr);
1789 
1790 	switch (field->operator) {
1791 	case FIELD_OP_MINUS:
1792 		strcat(expr, "-");
1793 		break;
1794 	case FIELD_OP_PLUS:
1795 		strcat(expr, "+");
1796 		break;
1797 	case FIELD_OP_DIV:
1798 		strcat(expr, "/");
1799 		break;
1800 	case FIELD_OP_MULT:
1801 		strcat(expr, "*");
1802 		break;
1803 	default:
1804 		kfree(expr);
1805 		return NULL;
1806 	}
1807 
1808 	expr_field_str(field->operands[1], expr);
1809 
1810 	return expr;
1811 }
1812 
1813 /*
1814  * If field_op != FIELD_OP_NONE, *sep points to the root operator
1815  * of the expression tree to be evaluated.
1816  */
1817 static int contains_operator(char *str, char **sep)
1818 {
1819 	enum field_op_id field_op = FIELD_OP_NONE;
1820 	char *minus_op, *plus_op, *div_op, *mult_op;
1821 
1822 
1823 	/*
1824 	 * Report the last occurrence of the operators first, so that the
1825 	 * expression is evaluated left to right. This is important since
1826 	 * subtraction and division are not associative.
1827 	 *
1828 	 *	e.g
1829 	 *		64/8/4/2 is 1, i.e 64/8/4/2 = ((64/8)/4)/2
1830 	 *		14-7-5-2 is 0, i.e 14-7-5-2 = ((14-7)-5)-2
1831 	 */
1832 
1833 	/*
1834 	 * First, find lower precedence addition and subtraction
1835 	 * since the expression will be evaluated recursively.
1836 	 */
1837 	minus_op = strrchr(str, '-');
1838 	if (minus_op) {
1839 		/*
1840 		 * Unary minus is not supported in sub-expressions. If
1841 		 * present, it is always the next root operator.
1842 		 */
1843 		if (minus_op == str) {
1844 			field_op = FIELD_OP_UNARY_MINUS;
1845 			goto out;
1846 		}
1847 
1848 		field_op = FIELD_OP_MINUS;
1849 	}
1850 
1851 	plus_op = strrchr(str, '+');
1852 	if (plus_op || minus_op) {
1853 		/*
1854 		 * For operators of the same precedence use to rightmost as the
1855 		 * root, so that the expression is evaluated left to right.
1856 		 */
1857 		if (plus_op > minus_op)
1858 			field_op = FIELD_OP_PLUS;
1859 		goto out;
1860 	}
1861 
1862 	/*
1863 	 * Multiplication and division have higher precedence than addition and
1864 	 * subtraction.
1865 	 */
1866 	div_op = strrchr(str, '/');
1867 	if (div_op)
1868 		field_op = FIELD_OP_DIV;
1869 
1870 	mult_op = strrchr(str, '*');
1871 	/*
1872 	 * For operators of the same precedence use to rightmost as the
1873 	 * root, so that the expression is evaluated left to right.
1874 	 */
1875 	if (mult_op > div_op)
1876 		field_op = FIELD_OP_MULT;
1877 
1878 out:
1879 	if (sep) {
1880 		switch (field_op) {
1881 		case FIELD_OP_UNARY_MINUS:
1882 		case FIELD_OP_MINUS:
1883 			*sep = minus_op;
1884 			break;
1885 		case FIELD_OP_PLUS:
1886 			*sep = plus_op;
1887 			break;
1888 		case FIELD_OP_DIV:
1889 			*sep = div_op;
1890 			break;
1891 		case FIELD_OP_MULT:
1892 			*sep = mult_op;
1893 			break;
1894 		case FIELD_OP_NONE:
1895 		default:
1896 			*sep = NULL;
1897 			break;
1898 		}
1899 	}
1900 
1901 	return field_op;
1902 }
1903 
1904 static void get_hist_field(struct hist_field *hist_field)
1905 {
1906 	hist_field->ref++;
1907 }
1908 
1909 static void __destroy_hist_field(struct hist_field *hist_field)
1910 {
1911 	if (--hist_field->ref > 1)
1912 		return;
1913 
1914 	kfree(hist_field->var.name);
1915 	kfree(hist_field->name);
1916 
1917 	/* Can likely be a const */
1918 	kfree_const(hist_field->type);
1919 
1920 	kfree(hist_field->system);
1921 	kfree(hist_field->event_name);
1922 
1923 	kfree(hist_field);
1924 }
1925 
1926 static void destroy_hist_field(struct hist_field *hist_field,
1927 			       unsigned int level)
1928 {
1929 	unsigned int i;
1930 
1931 	if (level > 3)
1932 		return;
1933 
1934 	if (!hist_field)
1935 		return;
1936 
1937 	if (hist_field->flags & HIST_FIELD_FL_VAR_REF)
1938 		return; /* var refs will be destroyed separately */
1939 
1940 	for (i = 0; i < HIST_FIELD_OPERANDS_MAX; i++)
1941 		destroy_hist_field(hist_field->operands[i], level + 1);
1942 
1943 	__destroy_hist_field(hist_field);
1944 }
1945 
1946 static struct hist_field *create_hist_field(struct hist_trigger_data *hist_data,
1947 					    struct ftrace_event_field *field,
1948 					    unsigned long flags,
1949 					    char *var_name)
1950 {
1951 	struct hist_field *hist_field;
1952 
1953 	if (field && is_function_field(field))
1954 		return NULL;
1955 
1956 	hist_field = kzalloc(sizeof(struct hist_field), GFP_KERNEL);
1957 	if (!hist_field)
1958 		return NULL;
1959 
1960 	hist_field->ref = 1;
1961 
1962 	hist_field->hist_data = hist_data;
1963 
1964 	if (flags & HIST_FIELD_FL_EXPR || flags & HIST_FIELD_FL_ALIAS)
1965 		goto out; /* caller will populate */
1966 
1967 	if (flags & HIST_FIELD_FL_VAR_REF) {
1968 		hist_field->fn_num = HIST_FIELD_FN_VAR_REF;
1969 		goto out;
1970 	}
1971 
1972 	if (flags & HIST_FIELD_FL_HITCOUNT) {
1973 		hist_field->fn_num = HIST_FIELD_FN_COUNTER;
1974 		hist_field->size = sizeof(u64);
1975 		hist_field->type = "u64";
1976 		goto out;
1977 	}
1978 
1979 	if (flags & HIST_FIELD_FL_CONST) {
1980 		hist_field->fn_num = HIST_FIELD_FN_CONST;
1981 		hist_field->size = sizeof(u64);
1982 		hist_field->type = kstrdup("u64", GFP_KERNEL);
1983 		if (!hist_field->type)
1984 			goto free;
1985 		goto out;
1986 	}
1987 
1988 	if (flags & HIST_FIELD_FL_STACKTRACE) {
1989 		if (field)
1990 			hist_field->fn_num = HIST_FIELD_FN_STACK;
1991 		else
1992 			hist_field->fn_num = HIST_FIELD_FN_NOP;
1993 		hist_field->size = HIST_STACKTRACE_SIZE;
1994 		hist_field->type = kstrdup_const("unsigned long[]", GFP_KERNEL);
1995 		if (!hist_field->type)
1996 			goto free;
1997 		goto out;
1998 	}
1999 
2000 	if (flags & (HIST_FIELD_FL_LOG2 | HIST_FIELD_FL_BUCKET)) {
2001 		unsigned long fl = flags & ~(HIST_FIELD_FL_LOG2 | HIST_FIELD_FL_BUCKET);
2002 		hist_field->fn_num = flags & HIST_FIELD_FL_LOG2 ? HIST_FIELD_FN_LOG2 :
2003 			HIST_FIELD_FN_BUCKET;
2004 		hist_field->operands[0] = create_hist_field(hist_data, field, fl, NULL);
2005 		if (!hist_field->operands[0])
2006 			goto free;
2007 		hist_field->size = hist_field->operands[0]->size;
2008 		hist_field->type = kstrdup_const(hist_field->operands[0]->type, GFP_KERNEL);
2009 		if (!hist_field->type)
2010 			goto free;
2011 		goto out;
2012 	}
2013 
2014 	if (flags & HIST_FIELD_FL_TIMESTAMP) {
2015 		hist_field->fn_num = HIST_FIELD_FN_TIMESTAMP;
2016 		hist_field->size = sizeof(u64);
2017 		hist_field->type = "u64";
2018 		goto out;
2019 	}
2020 
2021 	if (flags & HIST_FIELD_FL_CPU) {
2022 		hist_field->fn_num = HIST_FIELD_FN_CPU;
2023 		hist_field->size = sizeof(int);
2024 		hist_field->type = "unsigned int";
2025 		goto out;
2026 	}
2027 
2028 	if (WARN_ON_ONCE(!field))
2029 		goto out;
2030 
2031 	/* Pointers to strings are just pointers and dangerous to dereference */
2032 	if (is_string_field(field) &&
2033 	    (field->filter_type != FILTER_PTR_STRING)) {
2034 		flags |= HIST_FIELD_FL_STRING;
2035 
2036 		hist_field->size = MAX_FILTER_STR_VAL;
2037 		hist_field->type = kstrdup_const(field->type, GFP_KERNEL);
2038 		if (!hist_field->type)
2039 			goto free;
2040 
2041 		if (field->filter_type == FILTER_STATIC_STRING) {
2042 			hist_field->fn_num = HIST_FIELD_FN_STRING;
2043 			hist_field->size = field->size;
2044 		} else if (field->filter_type == FILTER_DYN_STRING) {
2045 			hist_field->fn_num = HIST_FIELD_FN_DYNSTRING;
2046 		} else if (field->filter_type == FILTER_RDYN_STRING)
2047 			hist_field->fn_num = HIST_FIELD_FN_RELDYNSTRING;
2048 		else
2049 			hist_field->fn_num = HIST_FIELD_FN_PSTRING;
2050 	} else {
2051 		hist_field->size = field->size;
2052 		hist_field->is_signed = field->is_signed;
2053 		hist_field->type = kstrdup_const(field->type, GFP_KERNEL);
2054 		if (!hist_field->type)
2055 			goto free;
2056 
2057 		hist_field->fn_num = select_value_fn(field->size,
2058 						     field->is_signed);
2059 		if (hist_field->fn_num == HIST_FIELD_FN_NOP) {
2060 			destroy_hist_field(hist_field, 0);
2061 			return NULL;
2062 		}
2063 	}
2064  out:
2065 	hist_field->field = field;
2066 	hist_field->flags = flags;
2067 
2068 	if (var_name) {
2069 		hist_field->var.name = kstrdup(var_name, GFP_KERNEL);
2070 		if (!hist_field->var.name)
2071 			goto free;
2072 	}
2073 
2074 	return hist_field;
2075  free:
2076 	destroy_hist_field(hist_field, 0);
2077 	return NULL;
2078 }
2079 
2080 static void destroy_hist_fields(struct hist_trigger_data *hist_data)
2081 {
2082 	unsigned int i;
2083 
2084 	for (i = 0; i < HIST_FIELDS_MAX; i++) {
2085 		if (hist_data->fields[i]) {
2086 			destroy_hist_field(hist_data->fields[i], 0);
2087 			hist_data->fields[i] = NULL;
2088 		}
2089 	}
2090 
2091 	for (i = 0; i < hist_data->n_var_refs; i++) {
2092 		WARN_ON(!(hist_data->var_refs[i]->flags & HIST_FIELD_FL_VAR_REF));
2093 		__destroy_hist_field(hist_data->var_refs[i]);
2094 		hist_data->var_refs[i] = NULL;
2095 	}
2096 }
2097 
2098 static int init_var_ref(struct hist_field *ref_field,
2099 			struct hist_field *var_field,
2100 			char *system, char *event_name)
2101 {
2102 	int err = 0;
2103 
2104 	ref_field->var.idx = var_field->var.idx;
2105 	ref_field->var.hist_data = var_field->hist_data;
2106 	ref_field->size = var_field->size;
2107 	ref_field->is_signed = var_field->is_signed;
2108 	ref_field->flags |= var_field->flags &
2109 		(HIST_FIELD_FL_TIMESTAMP | HIST_FIELD_FL_TIMESTAMP_USECS);
2110 
2111 	if (system) {
2112 		ref_field->system = kstrdup(system, GFP_KERNEL);
2113 		if (!ref_field->system)
2114 			return -ENOMEM;
2115 	}
2116 
2117 	if (event_name) {
2118 		ref_field->event_name = kstrdup(event_name, GFP_KERNEL);
2119 		if (!ref_field->event_name) {
2120 			err = -ENOMEM;
2121 			goto free;
2122 		}
2123 	}
2124 
2125 	if (var_field->var.name) {
2126 		ref_field->name = kstrdup(var_field->var.name, GFP_KERNEL);
2127 		if (!ref_field->name) {
2128 			err = -ENOMEM;
2129 			goto free;
2130 		}
2131 	} else if (var_field->name) {
2132 		ref_field->name = kstrdup(var_field->name, GFP_KERNEL);
2133 		if (!ref_field->name) {
2134 			err = -ENOMEM;
2135 			goto free;
2136 		}
2137 	}
2138 
2139 	ref_field->type = kstrdup_const(var_field->type, GFP_KERNEL);
2140 	if (!ref_field->type) {
2141 		err = -ENOMEM;
2142 		goto free;
2143 	}
2144  out:
2145 	return err;
2146  free:
2147 	kfree(ref_field->system);
2148 	ref_field->system = NULL;
2149 	kfree(ref_field->event_name);
2150 	ref_field->event_name = NULL;
2151 	kfree(ref_field->name);
2152 	ref_field->name = NULL;
2153 
2154 	goto out;
2155 }
2156 
2157 static int find_var_ref_idx(struct hist_trigger_data *hist_data,
2158 			    struct hist_field *var_field)
2159 {
2160 	struct hist_field *ref_field;
2161 	int i;
2162 
2163 	for (i = 0; i < hist_data->n_var_refs; i++) {
2164 		ref_field = hist_data->var_refs[i];
2165 		if (ref_field->var.idx == var_field->var.idx &&
2166 		    ref_field->var.hist_data == var_field->hist_data)
2167 			return i;
2168 	}
2169 
2170 	return -ENOENT;
2171 }
2172 
2173 /**
2174  * create_var_ref - Create a variable reference and attach it to trigger
2175  * @hist_data: The trigger that will be referencing the variable
2176  * @var_field: The VAR field to create a reference to
2177  * @system: The optional system string
2178  * @event_name: The optional event_name string
2179  *
2180  * Given a variable hist_field, create a VAR_REF hist_field that
2181  * represents a reference to it.
2182  *
2183  * This function also adds the reference to the trigger that
2184  * now references the variable.
2185  *
2186  * Return: The VAR_REF field if successful, NULL if not
2187  */
2188 static struct hist_field *create_var_ref(struct hist_trigger_data *hist_data,
2189 					 struct hist_field *var_field,
2190 					 char *system, char *event_name)
2191 {
2192 	unsigned long flags = HIST_FIELD_FL_VAR_REF;
2193 	struct hist_field *ref_field;
2194 	int i;
2195 
2196 	/* Check if the variable already exists */
2197 	for (i = 0; i < hist_data->n_var_refs; i++) {
2198 		ref_field = hist_data->var_refs[i];
2199 		if (ref_field->var.idx == var_field->var.idx &&
2200 		    ref_field->var.hist_data == var_field->hist_data) {
2201 			get_hist_field(ref_field);
2202 			return ref_field;
2203 		}
2204 	}
2205 	/* Sanity check to avoid out-of-bound write on 'hist_data->var_refs' */
2206 	if (hist_data->n_var_refs >= TRACING_MAP_VARS_MAX)
2207 		return NULL;
2208 	ref_field = create_hist_field(var_field->hist_data, NULL, flags, NULL);
2209 	if (ref_field) {
2210 		if (init_var_ref(ref_field, var_field, system, event_name)) {
2211 			destroy_hist_field(ref_field, 0);
2212 			return NULL;
2213 		}
2214 
2215 		hist_data->var_refs[hist_data->n_var_refs] = ref_field;
2216 		ref_field->var_ref_idx = hist_data->n_var_refs++;
2217 	}
2218 
2219 	return ref_field;
2220 }
2221 
2222 static bool is_var_ref(char *var_name)
2223 {
2224 	if (!var_name || strlen(var_name) < 2 || var_name[0] != '$')
2225 		return false;
2226 
2227 	return true;
2228 }
2229 
2230 static char *field_name_from_var(struct hist_trigger_data *hist_data,
2231 				 char *var_name)
2232 {
2233 	char *name, *field;
2234 	unsigned int i;
2235 
2236 	for (i = 0; i < hist_data->attrs->var_defs.n_vars; i++) {
2237 		name = hist_data->attrs->var_defs.name[i];
2238 
2239 		if (strcmp(var_name, name) == 0) {
2240 			field = hist_data->attrs->var_defs.expr[i];
2241 			if (contains_operator(field, NULL) || is_var_ref(field))
2242 				continue;
2243 			return field;
2244 		}
2245 	}
2246 
2247 	return NULL;
2248 }
2249 
2250 static char *local_field_var_ref(struct hist_trigger_data *hist_data,
2251 				 char *system, char *event_name,
2252 				 char *var_name)
2253 {
2254 	struct trace_event_call *call;
2255 
2256 	if (system && event_name) {
2257 		call = hist_data->event_file->event_call;
2258 
2259 		if (strcmp(system, call->class->system) != 0)
2260 			return NULL;
2261 
2262 		if (strcmp(event_name, trace_event_name(call)) != 0)
2263 			return NULL;
2264 	}
2265 
2266 	if (!!system != !!event_name)
2267 		return NULL;
2268 
2269 	if (!is_var_ref(var_name))
2270 		return NULL;
2271 
2272 	var_name++;
2273 
2274 	return field_name_from_var(hist_data, var_name);
2275 }
2276 
2277 static struct hist_field *parse_var_ref(struct hist_trigger_data *hist_data,
2278 					char *system, char *event_name,
2279 					char *var_name)
2280 {
2281 	struct hist_field *var_field = NULL, *ref_field = NULL;
2282 	struct trace_array *tr = hist_data->event_file->tr;
2283 
2284 	if (!is_var_ref(var_name))
2285 		return NULL;
2286 
2287 	var_name++;
2288 
2289 	var_field = find_event_var(hist_data, system, event_name, var_name);
2290 	if (var_field)
2291 		ref_field = create_var_ref(hist_data, var_field,
2292 					   system, event_name);
2293 
2294 	if (!ref_field)
2295 		hist_err(tr, HIST_ERR_VAR_NOT_FOUND, errpos(var_name));
2296 
2297 	return ref_field;
2298 }
2299 
2300 static struct ftrace_event_field *
2301 parse_field(struct hist_trigger_data *hist_data, struct trace_event_file *file,
2302 	    char *field_str, unsigned long *flags, unsigned long *buckets)
2303 {
2304 	struct ftrace_event_field *field = NULL;
2305 	char *field_name, *modifier, *str;
2306 	struct trace_array *tr = file->tr;
2307 
2308 	modifier = str = kstrdup(field_str, GFP_KERNEL);
2309 	if (!modifier)
2310 		return ERR_PTR(-ENOMEM);
2311 
2312 	field_name = strsep(&modifier, ".");
2313 	if (modifier) {
2314 		if (strcmp(modifier, "hex") == 0)
2315 			*flags |= HIST_FIELD_FL_HEX;
2316 		else if (strcmp(modifier, "sym") == 0)
2317 			*flags |= HIST_FIELD_FL_SYM;
2318 		/*
2319 		 * 'sym-offset' occurrences in the trigger string are modified
2320 		 * to 'symXoffset' to simplify arithmetic expression parsing.
2321 		 */
2322 		else if (strcmp(modifier, "symXoffset") == 0)
2323 			*flags |= HIST_FIELD_FL_SYM_OFFSET;
2324 		else if ((strcmp(modifier, "execname") == 0) &&
2325 			 (strcmp(field_name, "common_pid") == 0))
2326 			*flags |= HIST_FIELD_FL_EXECNAME;
2327 		else if (strcmp(modifier, "syscall") == 0)
2328 			*flags |= HIST_FIELD_FL_SYSCALL;
2329 		else if (strcmp(modifier, "stacktrace") == 0)
2330 			*flags |= HIST_FIELD_FL_STACKTRACE;
2331 		else if (strcmp(modifier, "log2") == 0)
2332 			*flags |= HIST_FIELD_FL_LOG2;
2333 		else if (strcmp(modifier, "usecs") == 0)
2334 			*flags |= HIST_FIELD_FL_TIMESTAMP_USECS;
2335 		else if (strncmp(modifier, "bucket", 6) == 0) {
2336 			int ret;
2337 
2338 			modifier += 6;
2339 
2340 			if (*modifier == 's')
2341 				modifier++;
2342 			if (*modifier != '=')
2343 				goto error;
2344 			modifier++;
2345 			ret = kstrtoul(modifier, 0, buckets);
2346 			if (ret || !(*buckets))
2347 				goto error;
2348 			*flags |= HIST_FIELD_FL_BUCKET;
2349 		} else if (strncmp(modifier, "percent", 7) == 0) {
2350 			if (*flags & (HIST_FIELD_FL_VAR | HIST_FIELD_FL_KEY))
2351 				goto error;
2352 			*flags |= HIST_FIELD_FL_PERCENT;
2353 		} else if (strncmp(modifier, "graph", 5) == 0) {
2354 			if (*flags & (HIST_FIELD_FL_VAR | HIST_FIELD_FL_KEY))
2355 				goto error;
2356 			*flags |= HIST_FIELD_FL_GRAPH;
2357 		} else {
2358  error:
2359 			hist_err(tr, HIST_ERR_BAD_FIELD_MODIFIER, errpos(modifier));
2360 			field = ERR_PTR(-EINVAL);
2361 			goto out;
2362 		}
2363 	}
2364 
2365 	if (strcmp(field_name, "common_timestamp") == 0) {
2366 		*flags |= HIST_FIELD_FL_TIMESTAMP;
2367 		hist_data->enable_timestamps = true;
2368 		if (*flags & HIST_FIELD_FL_TIMESTAMP_USECS)
2369 			hist_data->attrs->ts_in_usecs = true;
2370 	} else if (strcmp(field_name, "common_stacktrace") == 0) {
2371 		*flags |= HIST_FIELD_FL_STACKTRACE;
2372 	} else if (strcmp(field_name, "common_cpu") == 0)
2373 		*flags |= HIST_FIELD_FL_CPU;
2374 	else if (strcmp(field_name, "hitcount") == 0)
2375 		*flags |= HIST_FIELD_FL_HITCOUNT;
2376 	else {
2377 		field = trace_find_event_field(file->event_call, field_name);
2378 		if (!field || !field->size) {
2379 			/*
2380 			 * For backward compatibility, if field_name
2381 			 * was "cpu" or "stacktrace", then we treat this
2382 			 * the same as common_cpu and common_stacktrace
2383 			 * respectively. This also works for "CPU", and
2384 			 * "STACKTRACE".
2385 			 */
2386 			if (field && field->filter_type == FILTER_CPU) {
2387 				*flags |= HIST_FIELD_FL_CPU;
2388 			} else if (field && field->filter_type == FILTER_STACKTRACE) {
2389 				*flags |= HIST_FIELD_FL_STACKTRACE;
2390 			} else {
2391 				hist_err(tr, HIST_ERR_FIELD_NOT_FOUND,
2392 					 errpos(field_name));
2393 				field = ERR_PTR(-EINVAL);
2394 				goto out;
2395 			}
2396 		}
2397 	}
2398  out:
2399 	kfree(str);
2400 
2401 	return field;
2402 }
2403 
2404 static struct hist_field *create_alias(struct hist_trigger_data *hist_data,
2405 				       struct hist_field *var_ref,
2406 				       char *var_name)
2407 {
2408 	struct hist_field *alias = NULL;
2409 	unsigned long flags = HIST_FIELD_FL_ALIAS | HIST_FIELD_FL_VAR;
2410 
2411 	alias = create_hist_field(hist_data, NULL, flags, var_name);
2412 	if (!alias)
2413 		return NULL;
2414 
2415 	alias->fn_num = var_ref->fn_num;
2416 	alias->operands[0] = var_ref;
2417 
2418 	if (init_var_ref(alias, var_ref, var_ref->system, var_ref->event_name)) {
2419 		destroy_hist_field(alias, 0);
2420 		return NULL;
2421 	}
2422 
2423 	alias->var_ref_idx = var_ref->var_ref_idx;
2424 
2425 	return alias;
2426 }
2427 
2428 static struct hist_field *parse_const(struct hist_trigger_data *hist_data,
2429 				      char *str, char *var_name,
2430 				      unsigned long *flags)
2431 {
2432 	struct trace_array *tr = hist_data->event_file->tr;
2433 	struct hist_field *field = NULL;
2434 	u64 constant;
2435 
2436 	if (kstrtoull(str, 0, &constant)) {
2437 		hist_err(tr, HIST_ERR_EXPECT_NUMBER, errpos(str));
2438 		return NULL;
2439 	}
2440 
2441 	*flags |= HIST_FIELD_FL_CONST;
2442 	field = create_hist_field(hist_data, NULL, *flags, var_name);
2443 	if (!field)
2444 		return NULL;
2445 
2446 	field->constant = constant;
2447 
2448 	return field;
2449 }
2450 
2451 static struct hist_field *parse_atom(struct hist_trigger_data *hist_data,
2452 				     struct trace_event_file *file, char *str,
2453 				     unsigned long *flags, char *var_name)
2454 {
2455 	char *s, *ref_system = NULL, *ref_event = NULL, *ref_var = str;
2456 	struct ftrace_event_field *field = NULL;
2457 	struct hist_field *hist_field = NULL;
2458 	unsigned long buckets = 0;
2459 	int ret = 0;
2460 
2461 	if (isdigit(str[0])) {
2462 		hist_field = parse_const(hist_data, str, var_name, flags);
2463 		if (!hist_field) {
2464 			ret = -EINVAL;
2465 			goto out;
2466 		}
2467 		return hist_field;
2468 	}
2469 
2470 	s = strchr(str, '.');
2471 	if (s) {
2472 		s = strchr(++s, '.');
2473 		if (s) {
2474 			ref_system = strsep(&str, ".");
2475 			if (!str) {
2476 				ret = -EINVAL;
2477 				goto out;
2478 			}
2479 			ref_event = strsep(&str, ".");
2480 			if (!str) {
2481 				ret = -EINVAL;
2482 				goto out;
2483 			}
2484 			ref_var = str;
2485 		}
2486 	}
2487 
2488 	s = local_field_var_ref(hist_data, ref_system, ref_event, ref_var);
2489 	if (!s) {
2490 		hist_field = parse_var_ref(hist_data, ref_system,
2491 					   ref_event, ref_var);
2492 		if (hist_field) {
2493 			if (var_name) {
2494 				hist_field = create_alias(hist_data, hist_field, var_name);
2495 				if (!hist_field) {
2496 					ret = -ENOMEM;
2497 					goto out;
2498 				}
2499 			}
2500 			return hist_field;
2501 		}
2502 	} else
2503 		str = s;
2504 
2505 	field = parse_field(hist_data, file, str, flags, &buckets);
2506 	if (IS_ERR(field)) {
2507 		ret = PTR_ERR(field);
2508 		goto out;
2509 	}
2510 
2511 	hist_field = create_hist_field(hist_data, field, *flags, var_name);
2512 	if (!hist_field) {
2513 		ret = -ENOMEM;
2514 		goto out;
2515 	}
2516 	hist_field->buckets = buckets;
2517 
2518 	return hist_field;
2519  out:
2520 	return ERR_PTR(ret);
2521 }
2522 
2523 static struct hist_field *parse_expr(struct hist_trigger_data *hist_data,
2524 				     struct trace_event_file *file,
2525 				     char *str, unsigned long flags,
2526 				     char *var_name, unsigned int *n_subexprs);
2527 
2528 static struct hist_field *parse_unary(struct hist_trigger_data *hist_data,
2529 				      struct trace_event_file *file,
2530 				      char *str, unsigned long flags,
2531 				      char *var_name, unsigned int *n_subexprs)
2532 {
2533 	struct hist_field *operand1, *expr = NULL;
2534 	unsigned long operand_flags;
2535 	int ret = 0;
2536 	char *s;
2537 
2538 	/* Unary minus operator, increment n_subexprs */
2539 	++*n_subexprs;
2540 
2541 	/* we support only -(xxx) i.e. explicit parens required */
2542 
2543 	if (*n_subexprs > 3) {
2544 		hist_err(file->tr, HIST_ERR_TOO_MANY_SUBEXPR, errpos(str));
2545 		ret = -EINVAL;
2546 		goto free;
2547 	}
2548 
2549 	str++; /* skip leading '-' */
2550 
2551 	s = strchr(str, '(');
2552 	if (s)
2553 		str++;
2554 	else {
2555 		ret = -EINVAL;
2556 		goto free;
2557 	}
2558 
2559 	s = strrchr(str, ')');
2560 	if (s) {
2561 		 /* unary minus not supported in sub-expressions */
2562 		if (*(s+1) != '\0') {
2563 			hist_err(file->tr, HIST_ERR_UNARY_MINUS_SUBEXPR,
2564 				 errpos(str));
2565 			ret = -EINVAL;
2566 			goto free;
2567 		}
2568 		*s = '\0';
2569 	}
2570 	else {
2571 		ret = -EINVAL; /* no closing ')' */
2572 		goto free;
2573 	}
2574 
2575 	flags |= HIST_FIELD_FL_EXPR;
2576 	expr = create_hist_field(hist_data, NULL, flags, var_name);
2577 	if (!expr) {
2578 		ret = -ENOMEM;
2579 		goto free;
2580 	}
2581 
2582 	operand_flags = 0;
2583 	operand1 = parse_expr(hist_data, file, str, operand_flags, NULL, n_subexprs);
2584 	if (IS_ERR(operand1)) {
2585 		ret = PTR_ERR(operand1);
2586 		goto free;
2587 	}
2588 	if (operand1->flags & HIST_FIELD_FL_STRING) {
2589 		/* String type can not be the operand of unary operator. */
2590 		hist_err(file->tr, HIST_ERR_INVALID_STR_OPERAND, errpos(str));
2591 		destroy_hist_field(operand1, 0);
2592 		ret = -EINVAL;
2593 		goto free;
2594 	}
2595 
2596 	expr->flags |= operand1->flags &
2597 		(HIST_FIELD_FL_TIMESTAMP | HIST_FIELD_FL_TIMESTAMP_USECS);
2598 	expr->fn_num = HIST_FIELD_FN_UMINUS;
2599 	expr->operands[0] = operand1;
2600 	expr->size = operand1->size;
2601 	expr->is_signed = operand1->is_signed;
2602 	expr->operator = FIELD_OP_UNARY_MINUS;
2603 	expr->name = expr_str(expr, 0);
2604 	expr->type = kstrdup_const(operand1->type, GFP_KERNEL);
2605 	if (!expr->type) {
2606 		ret = -ENOMEM;
2607 		goto free;
2608 	}
2609 
2610 	return expr;
2611  free:
2612 	destroy_hist_field(expr, 0);
2613 	return ERR_PTR(ret);
2614 }
2615 
2616 /*
2617  * If the operands are var refs, return pointers the
2618  * variable(s) referenced in var1 and var2, else NULL.
2619  */
2620 static int check_expr_operands(struct trace_array *tr,
2621 			       struct hist_field *operand1,
2622 			       struct hist_field *operand2,
2623 			       struct hist_field **var1,
2624 			       struct hist_field **var2)
2625 {
2626 	unsigned long operand1_flags = operand1->flags;
2627 	unsigned long operand2_flags = operand2->flags;
2628 
2629 	if ((operand1_flags & HIST_FIELD_FL_VAR_REF) ||
2630 	    (operand1_flags & HIST_FIELD_FL_ALIAS)) {
2631 		struct hist_field *var;
2632 
2633 		var = find_var_field(operand1->var.hist_data, operand1->name);
2634 		if (!var)
2635 			return -EINVAL;
2636 		operand1_flags = var->flags;
2637 		*var1 = var;
2638 	}
2639 
2640 	if ((operand2_flags & HIST_FIELD_FL_VAR_REF) ||
2641 	    (operand2_flags & HIST_FIELD_FL_ALIAS)) {
2642 		struct hist_field *var;
2643 
2644 		var = find_var_field(operand2->var.hist_data, operand2->name);
2645 		if (!var)
2646 			return -EINVAL;
2647 		operand2_flags = var->flags;
2648 		*var2 = var;
2649 	}
2650 
2651 	if ((operand1_flags & HIST_FIELD_FL_TIMESTAMP_USECS) !=
2652 	    (operand2_flags & HIST_FIELD_FL_TIMESTAMP_USECS)) {
2653 		hist_err(tr, HIST_ERR_TIMESTAMP_MISMATCH, 0);
2654 		return -EINVAL;
2655 	}
2656 
2657 	return 0;
2658 }
2659 
2660 static struct hist_field *parse_expr(struct hist_trigger_data *hist_data,
2661 				     struct trace_event_file *file,
2662 				     char *str, unsigned long flags,
2663 				     char *var_name, unsigned int *n_subexprs)
2664 {
2665 	struct hist_field *operand1 = NULL, *operand2 = NULL, *expr = NULL;
2666 	struct hist_field *var1 = NULL, *var2 = NULL;
2667 	unsigned long operand_flags, operand2_flags;
2668 	int field_op, ret = -EINVAL;
2669 	char *sep, *operand1_str;
2670 	enum hist_field_fn op_fn;
2671 	bool combine_consts;
2672 
2673 	if (*n_subexprs > 3) {
2674 		hist_err(file->tr, HIST_ERR_TOO_MANY_SUBEXPR, errpos(str));
2675 		return ERR_PTR(-EINVAL);
2676 	}
2677 
2678 	field_op = contains_operator(str, &sep);
2679 
2680 	if (field_op == FIELD_OP_NONE)
2681 		return parse_atom(hist_data, file, str, &flags, var_name);
2682 
2683 	if (field_op == FIELD_OP_UNARY_MINUS)
2684 		return parse_unary(hist_data, file, str, flags, var_name, n_subexprs);
2685 
2686 	/* Binary operator found, increment n_subexprs */
2687 	++*n_subexprs;
2688 
2689 	/* Split the expression string at the root operator */
2690 	if (!sep)
2691 		return ERR_PTR(-EINVAL);
2692 
2693 	*sep = '\0';
2694 	operand1_str = str;
2695 	str = sep+1;
2696 
2697 	/* Binary operator requires both operands */
2698 	if (*operand1_str == '\0' || *str == '\0')
2699 		return ERR_PTR(-EINVAL);
2700 
2701 	operand_flags = 0;
2702 
2703 	/* LHS of string is an expression e.g. a+b in a+b+c */
2704 	operand1 = parse_expr(hist_data, file, operand1_str, operand_flags, NULL, n_subexprs);
2705 	if (IS_ERR(operand1))
2706 		return ERR_CAST(operand1);
2707 
2708 	if (operand1->flags & HIST_FIELD_FL_STRING) {
2709 		hist_err(file->tr, HIST_ERR_INVALID_STR_OPERAND, errpos(operand1_str));
2710 		ret = -EINVAL;
2711 		goto free_op1;
2712 	}
2713 
2714 	/* RHS of string is another expression e.g. c in a+b+c */
2715 	operand_flags = 0;
2716 	operand2 = parse_expr(hist_data, file, str, operand_flags, NULL, n_subexprs);
2717 	if (IS_ERR(operand2)) {
2718 		ret = PTR_ERR(operand2);
2719 		goto free_op1;
2720 	}
2721 	if (operand2->flags & HIST_FIELD_FL_STRING) {
2722 		hist_err(file->tr, HIST_ERR_INVALID_STR_OPERAND, errpos(str));
2723 		ret = -EINVAL;
2724 		goto free_operands;
2725 	}
2726 
2727 	switch (field_op) {
2728 	case FIELD_OP_MINUS:
2729 		op_fn = HIST_FIELD_FN_MINUS;
2730 		break;
2731 	case FIELD_OP_PLUS:
2732 		op_fn = HIST_FIELD_FN_PLUS;
2733 		break;
2734 	case FIELD_OP_DIV:
2735 		op_fn = HIST_FIELD_FN_DIV;
2736 		break;
2737 	case FIELD_OP_MULT:
2738 		op_fn = HIST_FIELD_FN_MULT;
2739 		break;
2740 	default:
2741 		ret = -EINVAL;
2742 		goto free_operands;
2743 	}
2744 
2745 	ret = check_expr_operands(file->tr, operand1, operand2, &var1, &var2);
2746 	if (ret)
2747 		goto free_operands;
2748 
2749 	operand_flags = var1 ? var1->flags : operand1->flags;
2750 	operand2_flags = var2 ? var2->flags : operand2->flags;
2751 
2752 	/*
2753 	 * If both operands are constant, the expression can be
2754 	 * collapsed to a single constant.
2755 	 */
2756 	combine_consts = operand_flags & operand2_flags & HIST_FIELD_FL_CONST;
2757 
2758 	flags |= combine_consts ? HIST_FIELD_FL_CONST : HIST_FIELD_FL_EXPR;
2759 
2760 	flags |= operand1->flags &
2761 		(HIST_FIELD_FL_TIMESTAMP | HIST_FIELD_FL_TIMESTAMP_USECS);
2762 
2763 	expr = create_hist_field(hist_data, NULL, flags, var_name);
2764 	if (!expr) {
2765 		ret = -ENOMEM;
2766 		goto free_operands;
2767 	}
2768 
2769 	operand1->read_once = true;
2770 	operand2->read_once = true;
2771 
2772 	/* The operands are now owned and free'd by 'expr' */
2773 	expr->operands[0] = operand1;
2774 	expr->operands[1] = operand2;
2775 
2776 	if (field_op == FIELD_OP_DIV &&
2777 			operand2_flags & HIST_FIELD_FL_CONST) {
2778 		u64 divisor = var2 ? var2->constant : operand2->constant;
2779 
2780 		if (!divisor) {
2781 			hist_err(file->tr, HIST_ERR_DIVISION_BY_ZERO, errpos(str));
2782 			ret = -EDOM;
2783 			goto free_expr;
2784 		}
2785 
2786 		/*
2787 		 * Copy the divisor here so we don't have to look it up
2788 		 * later if this is a var ref
2789 		 */
2790 		operand2->constant = divisor;
2791 		op_fn = hist_field_get_div_fn(operand2);
2792 	}
2793 
2794 	expr->fn_num = op_fn;
2795 
2796 	if (combine_consts) {
2797 		if (var1)
2798 			expr->operands[0] = var1;
2799 		if (var2)
2800 			expr->operands[1] = var2;
2801 
2802 		expr->constant = hist_fn_call(expr, NULL, NULL, NULL, NULL);
2803 		expr->fn_num = HIST_FIELD_FN_CONST;
2804 
2805 		expr->operands[0] = NULL;
2806 		expr->operands[1] = NULL;
2807 
2808 		/*
2809 		 * var refs won't be destroyed immediately
2810 		 * See: destroy_hist_field()
2811 		 */
2812 		destroy_hist_field(operand2, 0);
2813 		destroy_hist_field(operand1, 0);
2814 
2815 		expr->name = expr_str(expr, 0);
2816 	} else {
2817 		/* The operand sizes should be the same, so just pick one */
2818 		expr->size = operand1->size;
2819 		expr->is_signed = operand1->is_signed;
2820 
2821 		expr->operator = field_op;
2822 		expr->type = kstrdup_const(operand1->type, GFP_KERNEL);
2823 		if (!expr->type) {
2824 			ret = -ENOMEM;
2825 			goto free_expr;
2826 		}
2827 
2828 		expr->name = expr_str(expr, 0);
2829 	}
2830 
2831 	return expr;
2832 
2833 free_operands:
2834 	destroy_hist_field(operand2, 0);
2835 free_op1:
2836 	destroy_hist_field(operand1, 0);
2837 	return ERR_PTR(ret);
2838 
2839 free_expr:
2840 	destroy_hist_field(expr, 0);
2841 	return ERR_PTR(ret);
2842 }
2843 
2844 static char *find_trigger_filter(struct hist_trigger_data *hist_data,
2845 				 struct trace_event_file *file)
2846 {
2847 	struct event_trigger_data *test;
2848 
2849 	lockdep_assert_held(&event_mutex);
2850 
2851 	list_for_each_entry(test, &file->triggers, list) {
2852 		if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
2853 			if (test->private_data == hist_data)
2854 				return test->filter_str;
2855 		}
2856 	}
2857 
2858 	return NULL;
2859 }
2860 
2861 static struct event_command trigger_hist_cmd;
2862 static int event_hist_trigger_parse(struct event_command *cmd_ops,
2863 				    struct trace_event_file *file,
2864 				    char *glob, char *cmd,
2865 				    char *param_and_filter);
2866 
2867 static bool compatible_keys(struct hist_trigger_data *target_hist_data,
2868 			    struct hist_trigger_data *hist_data,
2869 			    unsigned int n_keys)
2870 {
2871 	struct hist_field *target_hist_field, *hist_field;
2872 	unsigned int n, i, j;
2873 
2874 	if (hist_data->n_fields - hist_data->n_vals != n_keys)
2875 		return false;
2876 
2877 	i = hist_data->n_vals;
2878 	j = target_hist_data->n_vals;
2879 
2880 	for (n = 0; n < n_keys; n++) {
2881 		hist_field = hist_data->fields[i + n];
2882 		target_hist_field = target_hist_data->fields[j + n];
2883 
2884 		if (strcmp(hist_field->type, target_hist_field->type) != 0)
2885 			return false;
2886 		if (hist_field->size != target_hist_field->size)
2887 			return false;
2888 		if (hist_field->is_signed != target_hist_field->is_signed)
2889 			return false;
2890 	}
2891 
2892 	return true;
2893 }
2894 
2895 static struct hist_trigger_data *
2896 find_compatible_hist(struct hist_trigger_data *target_hist_data,
2897 		     struct trace_event_file *file)
2898 {
2899 	struct hist_trigger_data *hist_data;
2900 	struct event_trigger_data *test;
2901 	unsigned int n_keys;
2902 
2903 	lockdep_assert_held(&event_mutex);
2904 
2905 	n_keys = target_hist_data->n_fields - target_hist_data->n_vals;
2906 
2907 	list_for_each_entry(test, &file->triggers, list) {
2908 		if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
2909 			hist_data = test->private_data;
2910 
2911 			if (compatible_keys(target_hist_data, hist_data, n_keys))
2912 				return hist_data;
2913 		}
2914 	}
2915 
2916 	return NULL;
2917 }
2918 
2919 static struct trace_event_file *event_file(struct trace_array *tr,
2920 					   char *system, char *event_name)
2921 {
2922 	struct trace_event_file *file;
2923 
2924 	file = __find_event_file(tr, system, event_name);
2925 	if (!file)
2926 		return ERR_PTR(-EINVAL);
2927 
2928 	return file;
2929 }
2930 
2931 static struct hist_field *
2932 find_synthetic_field_var(struct hist_trigger_data *target_hist_data,
2933 			 char *system, char *event_name, char *field_name)
2934 {
2935 	struct hist_field *event_var;
2936 	char *synthetic_name;
2937 
2938 	synthetic_name = kzalloc(MAX_FILTER_STR_VAL, GFP_KERNEL);
2939 	if (!synthetic_name)
2940 		return ERR_PTR(-ENOMEM);
2941 
2942 	strcpy(synthetic_name, "synthetic_");
2943 	strcat(synthetic_name, field_name);
2944 
2945 	event_var = find_event_var(target_hist_data, system, event_name, synthetic_name);
2946 
2947 	kfree(synthetic_name);
2948 
2949 	return event_var;
2950 }
2951 
2952 /**
2953  * create_field_var_hist - Automatically create a histogram and var for a field
2954  * @target_hist_data: The target hist trigger
2955  * @subsys_name: Optional subsystem name
2956  * @event_name: Optional event name
2957  * @field_name: The name of the field (and the resulting variable)
2958  *
2959  * Hist trigger actions fetch data from variables, not directly from
2960  * events.  However, for convenience, users are allowed to directly
2961  * specify an event field in an action, which will be automatically
2962  * converted into a variable on their behalf.
2963  *
2964  * If a user specifies a field on an event that isn't the event the
2965  * histogram currently being defined (the target event histogram), the
2966  * only way that can be accomplished is if a new hist trigger is
2967  * created and the field variable defined on that.
2968  *
2969  * This function creates a new histogram compatible with the target
2970  * event (meaning a histogram with the same key as the target
2971  * histogram), and creates a variable for the specified field, but
2972  * with 'synthetic_' prepended to the variable name in order to avoid
2973  * collision with normal field variables.
2974  *
2975  * Return: The variable created for the field.
2976  */
2977 static struct hist_field *
2978 create_field_var_hist(struct hist_trigger_data *target_hist_data,
2979 		      char *subsys_name, char *event_name, char *field_name)
2980 {
2981 	struct trace_array *tr = target_hist_data->event_file->tr;
2982 	struct hist_trigger_data *hist_data;
2983 	unsigned int i, n, first = true;
2984 	struct field_var_hist *var_hist;
2985 	struct trace_event_file *file;
2986 	struct hist_field *key_field;
2987 	struct hist_field *event_var;
2988 	char *saved_filter;
2989 	char *cmd;
2990 	int ret;
2991 
2992 	if (target_hist_data->n_field_var_hists >= SYNTH_FIELDS_MAX) {
2993 		hist_err(tr, HIST_ERR_TOO_MANY_FIELD_VARS, errpos(field_name));
2994 		return ERR_PTR(-EINVAL);
2995 	}
2996 
2997 	file = event_file(tr, subsys_name, event_name);
2998 
2999 	if (IS_ERR(file)) {
3000 		hist_err(tr, HIST_ERR_EVENT_FILE_NOT_FOUND, errpos(field_name));
3001 		ret = PTR_ERR(file);
3002 		return ERR_PTR(ret);
3003 	}
3004 
3005 	/*
3006 	 * Look for a histogram compatible with target.  We'll use the
3007 	 * found histogram specification to create a new matching
3008 	 * histogram with our variable on it.  target_hist_data is not
3009 	 * yet a registered histogram so we can't use that.
3010 	 */
3011 	hist_data = find_compatible_hist(target_hist_data, file);
3012 	if (!hist_data) {
3013 		hist_err(tr, HIST_ERR_HIST_NOT_FOUND, errpos(field_name));
3014 		return ERR_PTR(-EINVAL);
3015 	}
3016 
3017 	/* See if a synthetic field variable has already been created */
3018 	event_var = find_synthetic_field_var(target_hist_data, subsys_name,
3019 					     event_name, field_name);
3020 	if (!IS_ERR_OR_NULL(event_var))
3021 		return event_var;
3022 
3023 	var_hist = kzalloc(sizeof(*var_hist), GFP_KERNEL);
3024 	if (!var_hist)
3025 		return ERR_PTR(-ENOMEM);
3026 
3027 	cmd = kzalloc(MAX_FILTER_STR_VAL, GFP_KERNEL);
3028 	if (!cmd) {
3029 		kfree(var_hist);
3030 		return ERR_PTR(-ENOMEM);
3031 	}
3032 
3033 	/* Use the same keys as the compatible histogram */
3034 	strcat(cmd, "keys=");
3035 
3036 	for_each_hist_key_field(i, hist_data) {
3037 		key_field = hist_data->fields[i];
3038 		if (!first)
3039 			strcat(cmd, ",");
3040 		strcat(cmd, key_field->field->name);
3041 		first = false;
3042 	}
3043 
3044 	/* Create the synthetic field variable specification */
3045 	strcat(cmd, ":synthetic_");
3046 	strcat(cmd, field_name);
3047 	strcat(cmd, "=");
3048 	strcat(cmd, field_name);
3049 
3050 	/* Use the same filter as the compatible histogram */
3051 	saved_filter = find_trigger_filter(hist_data, file);
3052 	if (saved_filter) {
3053 		strcat(cmd, " if ");
3054 		strcat(cmd, saved_filter);
3055 	}
3056 
3057 	var_hist->cmd = kstrdup(cmd, GFP_KERNEL);
3058 	if (!var_hist->cmd) {
3059 		kfree(cmd);
3060 		kfree(var_hist);
3061 		return ERR_PTR(-ENOMEM);
3062 	}
3063 
3064 	/* Save the compatible histogram information */
3065 	var_hist->hist_data = hist_data;
3066 
3067 	/* Create the new histogram with our variable */
3068 	ret = event_hist_trigger_parse(&trigger_hist_cmd, file,
3069 				       "", "hist", cmd);
3070 	if (ret) {
3071 		kfree(cmd);
3072 		kfree(var_hist->cmd);
3073 		kfree(var_hist);
3074 		hist_err(tr, HIST_ERR_HIST_CREATE_FAIL, errpos(field_name));
3075 		return ERR_PTR(ret);
3076 	}
3077 
3078 	kfree(cmd);
3079 
3080 	/* If we can't find the variable, something went wrong */
3081 	event_var = find_synthetic_field_var(target_hist_data, subsys_name,
3082 					     event_name, field_name);
3083 	if (IS_ERR_OR_NULL(event_var)) {
3084 		kfree(var_hist->cmd);
3085 		kfree(var_hist);
3086 		hist_err(tr, HIST_ERR_SYNTH_VAR_NOT_FOUND, errpos(field_name));
3087 		return ERR_PTR(-EINVAL);
3088 	}
3089 
3090 	n = target_hist_data->n_field_var_hists;
3091 	target_hist_data->field_var_hists[n] = var_hist;
3092 	target_hist_data->n_field_var_hists++;
3093 
3094 	return event_var;
3095 }
3096 
3097 static struct hist_field *
3098 find_target_event_var(struct hist_trigger_data *hist_data,
3099 		      char *subsys_name, char *event_name, char *var_name)
3100 {
3101 	struct trace_event_file *file = hist_data->event_file;
3102 	struct hist_field *hist_field = NULL;
3103 
3104 	if (subsys_name) {
3105 		struct trace_event_call *call;
3106 
3107 		if (!event_name)
3108 			return NULL;
3109 
3110 		call = file->event_call;
3111 
3112 		if (strcmp(subsys_name, call->class->system) != 0)
3113 			return NULL;
3114 
3115 		if (strcmp(event_name, trace_event_name(call)) != 0)
3116 			return NULL;
3117 	}
3118 
3119 	hist_field = find_var_field(hist_data, var_name);
3120 
3121 	return hist_field;
3122 }
3123 
3124 static inline void __update_field_vars(struct tracing_map_elt *elt,
3125 				       struct trace_buffer *buffer,
3126 				       struct ring_buffer_event *rbe,
3127 				       void *rec,
3128 				       struct field_var **field_vars,
3129 				       unsigned int n_field_vars,
3130 				       unsigned int field_var_str_start)
3131 {
3132 	struct hist_elt_data *elt_data = elt->private_data;
3133 	unsigned int i, j, var_idx;
3134 	u64 var_val;
3135 
3136 	/* Make sure stacktrace can fit in the string variable length */
3137 	BUILD_BUG_ON((HIST_STACKTRACE_DEPTH + 1) * sizeof(long) >= STR_VAR_LEN_MAX);
3138 
3139 	for (i = 0, j = field_var_str_start; i < n_field_vars; i++) {
3140 		struct field_var *field_var = field_vars[i];
3141 		struct hist_field *var = field_var->var;
3142 		struct hist_field *val = field_var->val;
3143 
3144 		var_val = hist_fn_call(val, elt, buffer, rbe, rec);
3145 		var_idx = var->var.idx;
3146 
3147 		if (val->flags & (HIST_FIELD_FL_STRING |
3148 				  HIST_FIELD_FL_STACKTRACE)) {
3149 			char *str = elt_data->field_var_str[j++];
3150 			char *val_str = (char *)(uintptr_t)var_val;
3151 			unsigned int size;
3152 
3153 			if (val->flags & HIST_FIELD_FL_STRING) {
3154 				size = min(val->size, STR_VAR_LEN_MAX);
3155 				strscpy(str, val_str, size);
3156 			} else {
3157 				char *stack_start = str + sizeof(unsigned long);
3158 				int e;
3159 
3160 				e = stack_trace_save((void *)stack_start,
3161 						     HIST_STACKTRACE_DEPTH,
3162 						     HIST_STACKTRACE_SKIP);
3163 				if (e < HIST_STACKTRACE_DEPTH - 1)
3164 					((unsigned long *)stack_start)[e] = 0;
3165 				*((unsigned long *)str) = e;
3166 			}
3167 			var_val = (u64)(uintptr_t)str;
3168 		}
3169 		tracing_map_set_var(elt, var_idx, var_val);
3170 	}
3171 }
3172 
3173 static void update_field_vars(struct hist_trigger_data *hist_data,
3174 			      struct tracing_map_elt *elt,
3175 			      struct trace_buffer *buffer,
3176 			      struct ring_buffer_event *rbe,
3177 			      void *rec)
3178 {
3179 	__update_field_vars(elt, buffer, rbe, rec, hist_data->field_vars,
3180 			    hist_data->n_field_vars, 0);
3181 }
3182 
3183 static void save_track_data_vars(struct hist_trigger_data *hist_data,
3184 				 struct tracing_map_elt *elt,
3185 				 struct trace_buffer *buffer,  void *rec,
3186 				 struct ring_buffer_event *rbe, void *key,
3187 				 struct action_data *data, u64 *var_ref_vals)
3188 {
3189 	__update_field_vars(elt, buffer, rbe, rec, hist_data->save_vars,
3190 			    hist_data->n_save_vars, hist_data->n_field_var_str);
3191 }
3192 
3193 static struct hist_field *create_var(struct hist_trigger_data *hist_data,
3194 				     struct trace_event_file *file,
3195 				     char *name, int size, const char *type)
3196 {
3197 	struct hist_field *var;
3198 	int idx;
3199 
3200 	if (find_var(hist_data, file, name) && !hist_data->remove) {
3201 		var = ERR_PTR(-EINVAL);
3202 		goto out;
3203 	}
3204 
3205 	var = kzalloc(sizeof(struct hist_field), GFP_KERNEL);
3206 	if (!var) {
3207 		var = ERR_PTR(-ENOMEM);
3208 		goto out;
3209 	}
3210 
3211 	idx = tracing_map_add_var(hist_data->map);
3212 	if (idx < 0) {
3213 		kfree(var);
3214 		var = ERR_PTR(-EINVAL);
3215 		goto out;
3216 	}
3217 
3218 	var->ref = 1;
3219 	var->flags = HIST_FIELD_FL_VAR;
3220 	var->var.idx = idx;
3221 	var->var.hist_data = var->hist_data = hist_data;
3222 	var->size = size;
3223 	var->var.name = kstrdup(name, GFP_KERNEL);
3224 	var->type = kstrdup_const(type, GFP_KERNEL);
3225 	if (!var->var.name || !var->type) {
3226 		kfree_const(var->type);
3227 		kfree(var->var.name);
3228 		kfree(var);
3229 		var = ERR_PTR(-ENOMEM);
3230 	}
3231  out:
3232 	return var;
3233 }
3234 
3235 static struct field_var *create_field_var(struct hist_trigger_data *hist_data,
3236 					  struct trace_event_file *file,
3237 					  char *field_name)
3238 {
3239 	struct hist_field *val = NULL, *var = NULL;
3240 	unsigned long flags = HIST_FIELD_FL_VAR;
3241 	struct trace_array *tr = file->tr;
3242 	struct field_var *field_var;
3243 	int ret = 0;
3244 
3245 	if (hist_data->n_field_vars >= SYNTH_FIELDS_MAX) {
3246 		hist_err(tr, HIST_ERR_TOO_MANY_FIELD_VARS, errpos(field_name));
3247 		ret = -EINVAL;
3248 		goto err;
3249 	}
3250 
3251 	val = parse_atom(hist_data, file, field_name, &flags, NULL);
3252 	if (IS_ERR(val)) {
3253 		hist_err(tr, HIST_ERR_FIELD_VAR_PARSE_FAIL, errpos(field_name));
3254 		ret = PTR_ERR(val);
3255 		goto err;
3256 	}
3257 
3258 	var = create_var(hist_data, file, field_name, val->size, val->type);
3259 	if (IS_ERR(var)) {
3260 		hist_err(tr, HIST_ERR_VAR_CREATE_FIND_FAIL, errpos(field_name));
3261 		kfree(val);
3262 		ret = PTR_ERR(var);
3263 		goto err;
3264 	}
3265 
3266 	field_var = kzalloc(sizeof(struct field_var), GFP_KERNEL);
3267 	if (!field_var) {
3268 		kfree(val);
3269 		kfree(var);
3270 		ret =  -ENOMEM;
3271 		goto err;
3272 	}
3273 
3274 	field_var->var = var;
3275 	field_var->val = val;
3276  out:
3277 	return field_var;
3278  err:
3279 	field_var = ERR_PTR(ret);
3280 	goto out;
3281 }
3282 
3283 /**
3284  * create_target_field_var - Automatically create a variable for a field
3285  * @target_hist_data: The target hist trigger
3286  * @subsys_name: Optional subsystem name
3287  * @event_name: Optional event name
3288  * @var_name: The name of the field (and the resulting variable)
3289  *
3290  * Hist trigger actions fetch data from variables, not directly from
3291  * events.  However, for convenience, users are allowed to directly
3292  * specify an event field in an action, which will be automatically
3293  * converted into a variable on their behalf.
3294  *
3295  * This function creates a field variable with the name var_name on
3296  * the hist trigger currently being defined on the target event.  If
3297  * subsys_name and event_name are specified, this function simply
3298  * verifies that they do in fact match the target event subsystem and
3299  * event name.
3300  *
3301  * Return: The variable created for the field.
3302  */
3303 static struct field_var *
3304 create_target_field_var(struct hist_trigger_data *target_hist_data,
3305 			char *subsys_name, char *event_name, char *var_name)
3306 {
3307 	struct trace_event_file *file = target_hist_data->event_file;
3308 
3309 	if (subsys_name) {
3310 		struct trace_event_call *call;
3311 
3312 		if (!event_name)
3313 			return NULL;
3314 
3315 		call = file->event_call;
3316 
3317 		if (strcmp(subsys_name, call->class->system) != 0)
3318 			return NULL;
3319 
3320 		if (strcmp(event_name, trace_event_name(call)) != 0)
3321 			return NULL;
3322 	}
3323 
3324 	return create_field_var(target_hist_data, file, var_name);
3325 }
3326 
3327 static bool check_track_val_max(u64 track_val, u64 var_val)
3328 {
3329 	if (var_val <= track_val)
3330 		return false;
3331 
3332 	return true;
3333 }
3334 
3335 static bool check_track_val_changed(u64 track_val, u64 var_val)
3336 {
3337 	if (var_val == track_val)
3338 		return false;
3339 
3340 	return true;
3341 }
3342 
3343 static u64 get_track_val(struct hist_trigger_data *hist_data,
3344 			 struct tracing_map_elt *elt,
3345 			 struct action_data *data)
3346 {
3347 	unsigned int track_var_idx = data->track_data.track_var->var.idx;
3348 	u64 track_val;
3349 
3350 	track_val = tracing_map_read_var(elt, track_var_idx);
3351 
3352 	return track_val;
3353 }
3354 
3355 static void save_track_val(struct hist_trigger_data *hist_data,
3356 			   struct tracing_map_elt *elt,
3357 			   struct action_data *data, u64 var_val)
3358 {
3359 	unsigned int track_var_idx = data->track_data.track_var->var.idx;
3360 
3361 	tracing_map_set_var(elt, track_var_idx, var_val);
3362 }
3363 
3364 static void save_track_data(struct hist_trigger_data *hist_data,
3365 			    struct tracing_map_elt *elt,
3366 			    struct trace_buffer *buffer, void *rec,
3367 			    struct ring_buffer_event *rbe, void *key,
3368 			    struct action_data *data, u64 *var_ref_vals)
3369 {
3370 	if (data->track_data.save_data)
3371 		data->track_data.save_data(hist_data, elt, buffer, rec, rbe,
3372 					   key, data, var_ref_vals);
3373 }
3374 
3375 static bool check_track_val(struct tracing_map_elt *elt,
3376 			    struct action_data *data,
3377 			    u64 var_val)
3378 {
3379 	struct hist_trigger_data *hist_data;
3380 	u64 track_val;
3381 
3382 	hist_data = data->track_data.track_var->hist_data;
3383 	track_val = get_track_val(hist_data, elt, data);
3384 
3385 	return data->track_data.check_val(track_val, var_val);
3386 }
3387 
3388 #ifdef CONFIG_TRACER_SNAPSHOT
3389 static bool cond_snapshot_update(struct trace_array *tr, void *cond_data)
3390 {
3391 	/* called with tr->max_lock held */
3392 	struct track_data *track_data = tr->cond_snapshot->cond_data;
3393 	struct hist_elt_data *elt_data, *track_elt_data;
3394 	struct snapshot_context *context = cond_data;
3395 	struct action_data *action;
3396 	u64 track_val;
3397 
3398 	if (!track_data)
3399 		return false;
3400 
3401 	action = track_data->action_data;
3402 
3403 	track_val = get_track_val(track_data->hist_data, context->elt,
3404 				  track_data->action_data);
3405 
3406 	if (!action->track_data.check_val(track_data->track_val, track_val))
3407 		return false;
3408 
3409 	track_data->track_val = track_val;
3410 	memcpy(track_data->key, context->key, track_data->key_len);
3411 
3412 	elt_data = context->elt->private_data;
3413 	track_elt_data = track_data->elt.private_data;
3414 	if (elt_data->comm)
3415 		strncpy(track_elt_data->comm, elt_data->comm, TASK_COMM_LEN);
3416 
3417 	track_data->updated = true;
3418 
3419 	return true;
3420 }
3421 
3422 static void save_track_data_snapshot(struct hist_trigger_data *hist_data,
3423 				     struct tracing_map_elt *elt,
3424 				     struct trace_buffer *buffer, void *rec,
3425 				     struct ring_buffer_event *rbe, void *key,
3426 				     struct action_data *data,
3427 				     u64 *var_ref_vals)
3428 {
3429 	struct trace_event_file *file = hist_data->event_file;
3430 	struct snapshot_context context;
3431 
3432 	context.elt = elt;
3433 	context.key = key;
3434 
3435 	tracing_snapshot_cond(file->tr, &context);
3436 }
3437 
3438 static void hist_trigger_print_key(struct seq_file *m,
3439 				   struct hist_trigger_data *hist_data,
3440 				   void *key,
3441 				   struct tracing_map_elt *elt);
3442 
3443 static struct action_data *snapshot_action(struct hist_trigger_data *hist_data)
3444 {
3445 	unsigned int i;
3446 
3447 	if (!hist_data->n_actions)
3448 		return NULL;
3449 
3450 	for (i = 0; i < hist_data->n_actions; i++) {
3451 		struct action_data *data = hist_data->actions[i];
3452 
3453 		if (data->action == ACTION_SNAPSHOT)
3454 			return data;
3455 	}
3456 
3457 	return NULL;
3458 }
3459 
3460 static void track_data_snapshot_print(struct seq_file *m,
3461 				      struct hist_trigger_data *hist_data)
3462 {
3463 	struct trace_event_file *file = hist_data->event_file;
3464 	struct track_data *track_data;
3465 	struct action_data *action;
3466 
3467 	track_data = tracing_cond_snapshot_data(file->tr);
3468 	if (!track_data)
3469 		return;
3470 
3471 	if (!track_data->updated)
3472 		return;
3473 
3474 	action = snapshot_action(hist_data);
3475 	if (!action)
3476 		return;
3477 
3478 	seq_puts(m, "\nSnapshot taken (see tracing/snapshot).  Details:\n");
3479 	seq_printf(m, "\ttriggering value { %s(%s) }: %10llu",
3480 		   action->handler == HANDLER_ONMAX ? "onmax" : "onchange",
3481 		   action->track_data.var_str, track_data->track_val);
3482 
3483 	seq_puts(m, "\ttriggered by event with key: ");
3484 	hist_trigger_print_key(m, hist_data, track_data->key, &track_data->elt);
3485 	seq_putc(m, '\n');
3486 }
3487 #else
3488 static bool cond_snapshot_update(struct trace_array *tr, void *cond_data)
3489 {
3490 	return false;
3491 }
3492 static void save_track_data_snapshot(struct hist_trigger_data *hist_data,
3493 				     struct tracing_map_elt *elt,
3494 				     struct trace_buffer *buffer, void *rec,
3495 				     struct ring_buffer_event *rbe, void *key,
3496 				     struct action_data *data,
3497 				     u64 *var_ref_vals) {}
3498 static void track_data_snapshot_print(struct seq_file *m,
3499 				      struct hist_trigger_data *hist_data) {}
3500 #endif /* CONFIG_TRACER_SNAPSHOT */
3501 
3502 static void track_data_print(struct seq_file *m,
3503 			     struct hist_trigger_data *hist_data,
3504 			     struct tracing_map_elt *elt,
3505 			     struct action_data *data)
3506 {
3507 	u64 track_val = get_track_val(hist_data, elt, data);
3508 	unsigned int i, save_var_idx;
3509 
3510 	if (data->handler == HANDLER_ONMAX)
3511 		seq_printf(m, "\n\tmax: %10llu", track_val);
3512 	else if (data->handler == HANDLER_ONCHANGE)
3513 		seq_printf(m, "\n\tchanged: %10llu", track_val);
3514 
3515 	if (data->action == ACTION_SNAPSHOT)
3516 		return;
3517 
3518 	for (i = 0; i < hist_data->n_save_vars; i++) {
3519 		struct hist_field *save_val = hist_data->save_vars[i]->val;
3520 		struct hist_field *save_var = hist_data->save_vars[i]->var;
3521 		u64 val;
3522 
3523 		save_var_idx = save_var->var.idx;
3524 
3525 		val = tracing_map_read_var(elt, save_var_idx);
3526 
3527 		if (save_val->flags & HIST_FIELD_FL_STRING) {
3528 			seq_printf(m, "  %s: %-32s", save_var->var.name,
3529 				   (char *)(uintptr_t)(val));
3530 		} else
3531 			seq_printf(m, "  %s: %10llu", save_var->var.name, val);
3532 	}
3533 }
3534 
3535 static void ontrack_action(struct hist_trigger_data *hist_data,
3536 			   struct tracing_map_elt *elt,
3537 			   struct trace_buffer *buffer, void *rec,
3538 			   struct ring_buffer_event *rbe, void *key,
3539 			   struct action_data *data, u64 *var_ref_vals)
3540 {
3541 	u64 var_val = var_ref_vals[data->track_data.var_ref->var_ref_idx];
3542 
3543 	if (check_track_val(elt, data, var_val)) {
3544 		save_track_val(hist_data, elt, data, var_val);
3545 		save_track_data(hist_data, elt, buffer, rec, rbe,
3546 				key, data, var_ref_vals);
3547 	}
3548 }
3549 
3550 static void action_data_destroy(struct action_data *data)
3551 {
3552 	unsigned int i;
3553 
3554 	lockdep_assert_held(&event_mutex);
3555 
3556 	kfree(data->action_name);
3557 
3558 	for (i = 0; i < data->n_params; i++)
3559 		kfree(data->params[i]);
3560 
3561 	if (data->synth_event)
3562 		data->synth_event->ref--;
3563 
3564 	kfree(data->synth_event_name);
3565 
3566 	kfree(data);
3567 }
3568 
3569 static void track_data_destroy(struct hist_trigger_data *hist_data,
3570 			       struct action_data *data)
3571 {
3572 	struct trace_event_file *file = hist_data->event_file;
3573 
3574 	destroy_hist_field(data->track_data.track_var, 0);
3575 
3576 	if (data->action == ACTION_SNAPSHOT) {
3577 		struct track_data *track_data;
3578 
3579 		track_data = tracing_cond_snapshot_data(file->tr);
3580 		if (track_data && track_data->hist_data == hist_data) {
3581 			tracing_snapshot_cond_disable(file->tr);
3582 			track_data_free(track_data);
3583 		}
3584 	}
3585 
3586 	kfree(data->track_data.var_str);
3587 
3588 	action_data_destroy(data);
3589 }
3590 
3591 static int action_create(struct hist_trigger_data *hist_data,
3592 			 struct action_data *data);
3593 
3594 static int track_data_create(struct hist_trigger_data *hist_data,
3595 			     struct action_data *data)
3596 {
3597 	struct hist_field *var_field, *ref_field, *track_var = NULL;
3598 	struct trace_event_file *file = hist_data->event_file;
3599 	struct trace_array *tr = file->tr;
3600 	char *track_data_var_str;
3601 	int ret = 0;
3602 
3603 	track_data_var_str = data->track_data.var_str;
3604 	if (track_data_var_str[0] != '$') {
3605 		hist_err(tr, HIST_ERR_ONX_NOT_VAR, errpos(track_data_var_str));
3606 		return -EINVAL;
3607 	}
3608 	track_data_var_str++;
3609 
3610 	var_field = find_target_event_var(hist_data, NULL, NULL, track_data_var_str);
3611 	if (!var_field) {
3612 		hist_err(tr, HIST_ERR_ONX_VAR_NOT_FOUND, errpos(track_data_var_str));
3613 		return -EINVAL;
3614 	}
3615 
3616 	ref_field = create_var_ref(hist_data, var_field, NULL, NULL);
3617 	if (!ref_field)
3618 		return -ENOMEM;
3619 
3620 	data->track_data.var_ref = ref_field;
3621 
3622 	if (data->handler == HANDLER_ONMAX)
3623 		track_var = create_var(hist_data, file, "__max", sizeof(u64), "u64");
3624 	if (IS_ERR(track_var)) {
3625 		hist_err(tr, HIST_ERR_ONX_VAR_CREATE_FAIL, 0);
3626 		ret = PTR_ERR(track_var);
3627 		goto out;
3628 	}
3629 
3630 	if (data->handler == HANDLER_ONCHANGE)
3631 		track_var = create_var(hist_data, file, "__change", sizeof(u64), "u64");
3632 	if (IS_ERR(track_var)) {
3633 		hist_err(tr, HIST_ERR_ONX_VAR_CREATE_FAIL, 0);
3634 		ret = PTR_ERR(track_var);
3635 		goto out;
3636 	}
3637 	data->track_data.track_var = track_var;
3638 
3639 	ret = action_create(hist_data, data);
3640  out:
3641 	return ret;
3642 }
3643 
3644 static int parse_action_params(struct trace_array *tr, char *params,
3645 			       struct action_data *data)
3646 {
3647 	char *param, *saved_param;
3648 	bool first_param = true;
3649 	int ret = 0;
3650 
3651 	while (params) {
3652 		if (data->n_params >= SYNTH_FIELDS_MAX) {
3653 			hist_err(tr, HIST_ERR_TOO_MANY_PARAMS, 0);
3654 			ret = -EINVAL;
3655 			goto out;
3656 		}
3657 
3658 		param = strsep(&params, ",");
3659 		if (!param) {
3660 			hist_err(tr, HIST_ERR_PARAM_NOT_FOUND, 0);
3661 			ret = -EINVAL;
3662 			goto out;
3663 		}
3664 
3665 		param = strstrip(param);
3666 		if (strlen(param) < 2) {
3667 			hist_err(tr, HIST_ERR_INVALID_PARAM, errpos(param));
3668 			ret = -EINVAL;
3669 			goto out;
3670 		}
3671 
3672 		saved_param = kstrdup(param, GFP_KERNEL);
3673 		if (!saved_param) {
3674 			ret = -ENOMEM;
3675 			goto out;
3676 		}
3677 
3678 		if (first_param && data->use_trace_keyword) {
3679 			data->synth_event_name = saved_param;
3680 			first_param = false;
3681 			continue;
3682 		}
3683 		first_param = false;
3684 
3685 		data->params[data->n_params++] = saved_param;
3686 	}
3687  out:
3688 	return ret;
3689 }
3690 
3691 static int action_parse(struct trace_array *tr, char *str, struct action_data *data,
3692 			enum handler_id handler)
3693 {
3694 	char *action_name;
3695 	int ret = 0;
3696 
3697 	strsep(&str, ".");
3698 	if (!str) {
3699 		hist_err(tr, HIST_ERR_ACTION_NOT_FOUND, 0);
3700 		ret = -EINVAL;
3701 		goto out;
3702 	}
3703 
3704 	action_name = strsep(&str, "(");
3705 	if (!action_name || !str) {
3706 		hist_err(tr, HIST_ERR_ACTION_NOT_FOUND, 0);
3707 		ret = -EINVAL;
3708 		goto out;
3709 	}
3710 
3711 	if (str_has_prefix(action_name, "save")) {
3712 		char *params = strsep(&str, ")");
3713 
3714 		if (!params) {
3715 			hist_err(tr, HIST_ERR_NO_SAVE_PARAMS, 0);
3716 			ret = -EINVAL;
3717 			goto out;
3718 		}
3719 
3720 		ret = parse_action_params(tr, params, data);
3721 		if (ret)
3722 			goto out;
3723 
3724 		if (handler == HANDLER_ONMAX)
3725 			data->track_data.check_val = check_track_val_max;
3726 		else if (handler == HANDLER_ONCHANGE)
3727 			data->track_data.check_val = check_track_val_changed;
3728 		else {
3729 			hist_err(tr, HIST_ERR_ACTION_MISMATCH, errpos(action_name));
3730 			ret = -EINVAL;
3731 			goto out;
3732 		}
3733 
3734 		data->track_data.save_data = save_track_data_vars;
3735 		data->fn = ontrack_action;
3736 		data->action = ACTION_SAVE;
3737 	} else if (str_has_prefix(action_name, "snapshot")) {
3738 		char *params = strsep(&str, ")");
3739 
3740 		if (!str) {
3741 			hist_err(tr, HIST_ERR_NO_CLOSING_PAREN, errpos(params));
3742 			ret = -EINVAL;
3743 			goto out;
3744 		}
3745 
3746 		if (handler == HANDLER_ONMAX)
3747 			data->track_data.check_val = check_track_val_max;
3748 		else if (handler == HANDLER_ONCHANGE)
3749 			data->track_data.check_val = check_track_val_changed;
3750 		else {
3751 			hist_err(tr, HIST_ERR_ACTION_MISMATCH, errpos(action_name));
3752 			ret = -EINVAL;
3753 			goto out;
3754 		}
3755 
3756 		data->track_data.save_data = save_track_data_snapshot;
3757 		data->fn = ontrack_action;
3758 		data->action = ACTION_SNAPSHOT;
3759 	} else {
3760 		char *params = strsep(&str, ")");
3761 
3762 		if (str_has_prefix(action_name, "trace"))
3763 			data->use_trace_keyword = true;
3764 
3765 		if (params) {
3766 			ret = parse_action_params(tr, params, data);
3767 			if (ret)
3768 				goto out;
3769 		}
3770 
3771 		if (handler == HANDLER_ONMAX)
3772 			data->track_data.check_val = check_track_val_max;
3773 		else if (handler == HANDLER_ONCHANGE)
3774 			data->track_data.check_val = check_track_val_changed;
3775 
3776 		if (handler != HANDLER_ONMATCH) {
3777 			data->track_data.save_data = action_trace;
3778 			data->fn = ontrack_action;
3779 		} else
3780 			data->fn = action_trace;
3781 
3782 		data->action = ACTION_TRACE;
3783 	}
3784 
3785 	data->action_name = kstrdup(action_name, GFP_KERNEL);
3786 	if (!data->action_name) {
3787 		ret = -ENOMEM;
3788 		goto out;
3789 	}
3790 
3791 	data->handler = handler;
3792  out:
3793 	return ret;
3794 }
3795 
3796 static struct action_data *track_data_parse(struct hist_trigger_data *hist_data,
3797 					    char *str, enum handler_id handler)
3798 {
3799 	struct action_data *data;
3800 	int ret = -EINVAL;
3801 	char *var_str;
3802 
3803 	data = kzalloc(sizeof(*data), GFP_KERNEL);
3804 	if (!data)
3805 		return ERR_PTR(-ENOMEM);
3806 
3807 	var_str = strsep(&str, ")");
3808 	if (!var_str || !str) {
3809 		ret = -EINVAL;
3810 		goto free;
3811 	}
3812 
3813 	data->track_data.var_str = kstrdup(var_str, GFP_KERNEL);
3814 	if (!data->track_data.var_str) {
3815 		ret = -ENOMEM;
3816 		goto free;
3817 	}
3818 
3819 	ret = action_parse(hist_data->event_file->tr, str, data, handler);
3820 	if (ret)
3821 		goto free;
3822  out:
3823 	return data;
3824  free:
3825 	track_data_destroy(hist_data, data);
3826 	data = ERR_PTR(ret);
3827 	goto out;
3828 }
3829 
3830 static void onmatch_destroy(struct action_data *data)
3831 {
3832 	kfree(data->match_data.event);
3833 	kfree(data->match_data.event_system);
3834 
3835 	action_data_destroy(data);
3836 }
3837 
3838 static void destroy_field_var(struct field_var *field_var)
3839 {
3840 	if (!field_var)
3841 		return;
3842 
3843 	destroy_hist_field(field_var->var, 0);
3844 	destroy_hist_field(field_var->val, 0);
3845 
3846 	kfree(field_var);
3847 }
3848 
3849 static void destroy_field_vars(struct hist_trigger_data *hist_data)
3850 {
3851 	unsigned int i;
3852 
3853 	for (i = 0; i < hist_data->n_field_vars; i++)
3854 		destroy_field_var(hist_data->field_vars[i]);
3855 
3856 	for (i = 0; i < hist_data->n_save_vars; i++)
3857 		destroy_field_var(hist_data->save_vars[i]);
3858 }
3859 
3860 static void save_field_var(struct hist_trigger_data *hist_data,
3861 			   struct field_var *field_var)
3862 {
3863 	hist_data->field_vars[hist_data->n_field_vars++] = field_var;
3864 
3865 	/* Stack traces are saved in the string storage too */
3866 	if (field_var->val->flags & (HIST_FIELD_FL_STRING | HIST_FIELD_FL_STACKTRACE))
3867 		hist_data->n_field_var_str++;
3868 }
3869 
3870 
3871 static int check_synth_field(struct synth_event *event,
3872 			     struct hist_field *hist_field,
3873 			     unsigned int field_pos)
3874 {
3875 	struct synth_field *field;
3876 
3877 	if (field_pos >= event->n_fields)
3878 		return -EINVAL;
3879 
3880 	field = event->fields[field_pos];
3881 
3882 	/*
3883 	 * A dynamic string synth field can accept static or
3884 	 * dynamic. A static string synth field can only accept a
3885 	 * same-sized static string, which is checked for later.
3886 	 */
3887 	if (strstr(hist_field->type, "char[") && field->is_string
3888 	    && field->is_dynamic)
3889 		return 0;
3890 
3891 	if (strstr(hist_field->type, "long[") && field->is_stack)
3892 		return 0;
3893 
3894 	if (strcmp(field->type, hist_field->type) != 0) {
3895 		if (field->size != hist_field->size ||
3896 		    (!field->is_string && field->is_signed != hist_field->is_signed))
3897 			return -EINVAL;
3898 	}
3899 
3900 	return 0;
3901 }
3902 
3903 static struct hist_field *
3904 trace_action_find_var(struct hist_trigger_data *hist_data,
3905 		      struct action_data *data,
3906 		      char *system, char *event, char *var)
3907 {
3908 	struct trace_array *tr = hist_data->event_file->tr;
3909 	struct hist_field *hist_field;
3910 
3911 	var++; /* skip '$' */
3912 
3913 	hist_field = find_target_event_var(hist_data, system, event, var);
3914 	if (!hist_field) {
3915 		if (!system && data->handler == HANDLER_ONMATCH) {
3916 			system = data->match_data.event_system;
3917 			event = data->match_data.event;
3918 		}
3919 
3920 		hist_field = find_event_var(hist_data, system, event, var);
3921 	}
3922 
3923 	if (!hist_field)
3924 		hist_err(tr, HIST_ERR_PARAM_NOT_FOUND, errpos(var));
3925 
3926 	return hist_field;
3927 }
3928 
3929 static struct hist_field *
3930 trace_action_create_field_var(struct hist_trigger_data *hist_data,
3931 			      struct action_data *data, char *system,
3932 			      char *event, char *var)
3933 {
3934 	struct hist_field *hist_field = NULL;
3935 	struct field_var *field_var;
3936 
3937 	/*
3938 	 * First try to create a field var on the target event (the
3939 	 * currently being defined).  This will create a variable for
3940 	 * unqualified fields on the target event, or if qualified,
3941 	 * target fields that have qualified names matching the target.
3942 	 */
3943 	field_var = create_target_field_var(hist_data, system, event, var);
3944 
3945 	if (field_var && !IS_ERR(field_var)) {
3946 		save_field_var(hist_data, field_var);
3947 		hist_field = field_var->var;
3948 	} else {
3949 		field_var = NULL;
3950 		/*
3951 		 * If no explicit system.event is specified, default to
3952 		 * looking for fields on the onmatch(system.event.xxx)
3953 		 * event.
3954 		 */
3955 		if (!system && data->handler == HANDLER_ONMATCH) {
3956 			system = data->match_data.event_system;
3957 			event = data->match_data.event;
3958 		}
3959 
3960 		if (!event)
3961 			goto free;
3962 		/*
3963 		 * At this point, we're looking at a field on another
3964 		 * event.  Because we can't modify a hist trigger on
3965 		 * another event to add a variable for a field, we need
3966 		 * to create a new trigger on that event and create the
3967 		 * variable at the same time.
3968 		 */
3969 		hist_field = create_field_var_hist(hist_data, system, event, var);
3970 		if (IS_ERR(hist_field))
3971 			goto free;
3972 	}
3973  out:
3974 	return hist_field;
3975  free:
3976 	destroy_field_var(field_var);
3977 	hist_field = NULL;
3978 	goto out;
3979 }
3980 
3981 static int trace_action_create(struct hist_trigger_data *hist_data,
3982 			       struct action_data *data)
3983 {
3984 	struct trace_array *tr = hist_data->event_file->tr;
3985 	char *event_name, *param, *system = NULL;
3986 	struct hist_field *hist_field, *var_ref;
3987 	unsigned int i;
3988 	unsigned int field_pos = 0;
3989 	struct synth_event *event;
3990 	char *synth_event_name;
3991 	int var_ref_idx, ret = 0;
3992 
3993 	lockdep_assert_held(&event_mutex);
3994 
3995 	/* Sanity check to avoid out-of-bound write on 'data->var_ref_idx' */
3996 	if (data->n_params > SYNTH_FIELDS_MAX)
3997 		return -EINVAL;
3998 
3999 	if (data->use_trace_keyword)
4000 		synth_event_name = data->synth_event_name;
4001 	else
4002 		synth_event_name = data->action_name;
4003 
4004 	event = find_synth_event(synth_event_name);
4005 	if (!event) {
4006 		hist_err(tr, HIST_ERR_SYNTH_EVENT_NOT_FOUND, errpos(synth_event_name));
4007 		return -EINVAL;
4008 	}
4009 
4010 	event->ref++;
4011 
4012 	for (i = 0; i < data->n_params; i++) {
4013 		char *p;
4014 
4015 		p = param = kstrdup(data->params[i], GFP_KERNEL);
4016 		if (!param) {
4017 			ret = -ENOMEM;
4018 			goto err;
4019 		}
4020 
4021 		system = strsep(&param, ".");
4022 		if (!param) {
4023 			param = (char *)system;
4024 			system = event_name = NULL;
4025 		} else {
4026 			event_name = strsep(&param, ".");
4027 			if (!param) {
4028 				kfree(p);
4029 				ret = -EINVAL;
4030 				goto err;
4031 			}
4032 		}
4033 
4034 		if (param[0] == '$')
4035 			hist_field = trace_action_find_var(hist_data, data,
4036 							   system, event_name,
4037 							   param);
4038 		else
4039 			hist_field = trace_action_create_field_var(hist_data,
4040 								   data,
4041 								   system,
4042 								   event_name,
4043 								   param);
4044 
4045 		if (!hist_field) {
4046 			kfree(p);
4047 			ret = -EINVAL;
4048 			goto err;
4049 		}
4050 
4051 		if (check_synth_field(event, hist_field, field_pos) == 0) {
4052 			var_ref = create_var_ref(hist_data, hist_field,
4053 						 system, event_name);
4054 			if (!var_ref) {
4055 				kfree(p);
4056 				ret = -ENOMEM;
4057 				goto err;
4058 			}
4059 
4060 			var_ref_idx = find_var_ref_idx(hist_data, var_ref);
4061 			if (WARN_ON(var_ref_idx < 0)) {
4062 				kfree(p);
4063 				ret = var_ref_idx;
4064 				goto err;
4065 			}
4066 
4067 			data->var_ref_idx[i] = var_ref_idx;
4068 
4069 			field_pos++;
4070 			kfree(p);
4071 			continue;
4072 		}
4073 
4074 		hist_err(tr, HIST_ERR_SYNTH_TYPE_MISMATCH, errpos(param));
4075 		kfree(p);
4076 		ret = -EINVAL;
4077 		goto err;
4078 	}
4079 
4080 	if (field_pos != event->n_fields) {
4081 		hist_err(tr, HIST_ERR_SYNTH_COUNT_MISMATCH, errpos(event->name));
4082 		ret = -EINVAL;
4083 		goto err;
4084 	}
4085 
4086 	data->synth_event = event;
4087  out:
4088 	return ret;
4089  err:
4090 	event->ref--;
4091 
4092 	goto out;
4093 }
4094 
4095 static int action_create(struct hist_trigger_data *hist_data,
4096 			 struct action_data *data)
4097 {
4098 	struct trace_event_file *file = hist_data->event_file;
4099 	struct trace_array *tr = file->tr;
4100 	struct track_data *track_data;
4101 	struct field_var *field_var;
4102 	unsigned int i;
4103 	char *param;
4104 	int ret = 0;
4105 
4106 	if (data->action == ACTION_TRACE)
4107 		return trace_action_create(hist_data, data);
4108 
4109 	if (data->action == ACTION_SNAPSHOT) {
4110 		track_data = track_data_alloc(hist_data->key_size, data, hist_data);
4111 		if (IS_ERR(track_data)) {
4112 			ret = PTR_ERR(track_data);
4113 			goto out;
4114 		}
4115 
4116 		ret = tracing_snapshot_cond_enable(file->tr, track_data,
4117 						   cond_snapshot_update);
4118 		if (ret)
4119 			track_data_free(track_data);
4120 
4121 		goto out;
4122 	}
4123 
4124 	if (data->action == ACTION_SAVE) {
4125 		if (hist_data->n_save_vars) {
4126 			ret = -EEXIST;
4127 			hist_err(tr, HIST_ERR_TOO_MANY_SAVE_ACTIONS, 0);
4128 			goto out;
4129 		}
4130 
4131 		for (i = 0; i < data->n_params; i++) {
4132 			param = kstrdup(data->params[i], GFP_KERNEL);
4133 			if (!param) {
4134 				ret = -ENOMEM;
4135 				goto out;
4136 			}
4137 
4138 			field_var = create_target_field_var(hist_data, NULL, NULL, param);
4139 			if (IS_ERR(field_var)) {
4140 				hist_err(tr, HIST_ERR_FIELD_VAR_CREATE_FAIL,
4141 					 errpos(param));
4142 				ret = PTR_ERR(field_var);
4143 				kfree(param);
4144 				goto out;
4145 			}
4146 
4147 			hist_data->save_vars[hist_data->n_save_vars++] = field_var;
4148 			if (field_var->val->flags &
4149 			    (HIST_FIELD_FL_STRING | HIST_FIELD_FL_STACKTRACE))
4150 				hist_data->n_save_var_str++;
4151 			kfree(param);
4152 		}
4153 	}
4154  out:
4155 	return ret;
4156 }
4157 
4158 static int onmatch_create(struct hist_trigger_data *hist_data,
4159 			  struct action_data *data)
4160 {
4161 	return action_create(hist_data, data);
4162 }
4163 
4164 static struct action_data *onmatch_parse(struct trace_array *tr, char *str)
4165 {
4166 	char *match_event, *match_event_system;
4167 	struct action_data *data;
4168 	int ret = -EINVAL;
4169 
4170 	data = kzalloc(sizeof(*data), GFP_KERNEL);
4171 	if (!data)
4172 		return ERR_PTR(-ENOMEM);
4173 
4174 	match_event = strsep(&str, ")");
4175 	if (!match_event || !str) {
4176 		hist_err(tr, HIST_ERR_NO_CLOSING_PAREN, errpos(match_event));
4177 		goto free;
4178 	}
4179 
4180 	match_event_system = strsep(&match_event, ".");
4181 	if (!match_event) {
4182 		hist_err(tr, HIST_ERR_SUBSYS_NOT_FOUND, errpos(match_event_system));
4183 		goto free;
4184 	}
4185 
4186 	if (IS_ERR(event_file(tr, match_event_system, match_event))) {
4187 		hist_err(tr, HIST_ERR_INVALID_SUBSYS_EVENT, errpos(match_event));
4188 		goto free;
4189 	}
4190 
4191 	data->match_data.event = kstrdup(match_event, GFP_KERNEL);
4192 	if (!data->match_data.event) {
4193 		ret = -ENOMEM;
4194 		goto free;
4195 	}
4196 
4197 	data->match_data.event_system = kstrdup(match_event_system, GFP_KERNEL);
4198 	if (!data->match_data.event_system) {
4199 		ret = -ENOMEM;
4200 		goto free;
4201 	}
4202 
4203 	ret = action_parse(tr, str, data, HANDLER_ONMATCH);
4204 	if (ret)
4205 		goto free;
4206  out:
4207 	return data;
4208  free:
4209 	onmatch_destroy(data);
4210 	data = ERR_PTR(ret);
4211 	goto out;
4212 }
4213 
4214 static int create_hitcount_val(struct hist_trigger_data *hist_data)
4215 {
4216 	hist_data->fields[HITCOUNT_IDX] =
4217 		create_hist_field(hist_data, NULL, HIST_FIELD_FL_HITCOUNT, NULL);
4218 	if (!hist_data->fields[HITCOUNT_IDX])
4219 		return -ENOMEM;
4220 
4221 	hist_data->n_vals++;
4222 	hist_data->n_fields++;
4223 
4224 	if (WARN_ON(hist_data->n_vals > TRACING_MAP_VALS_MAX))
4225 		return -EINVAL;
4226 
4227 	return 0;
4228 }
4229 
4230 static int __create_val_field(struct hist_trigger_data *hist_data,
4231 			      unsigned int val_idx,
4232 			      struct trace_event_file *file,
4233 			      char *var_name, char *field_str,
4234 			      unsigned long flags)
4235 {
4236 	struct hist_field *hist_field;
4237 	int ret = 0, n_subexprs = 0;
4238 
4239 	hist_field = parse_expr(hist_data, file, field_str, flags, var_name, &n_subexprs);
4240 	if (IS_ERR(hist_field)) {
4241 		ret = PTR_ERR(hist_field);
4242 		goto out;
4243 	}
4244 
4245 	/* values and variables should not have some modifiers */
4246 	if (hist_field->flags & HIST_FIELD_FL_VAR) {
4247 		/* Variable */
4248 		if (hist_field->flags & (HIST_FIELD_FL_GRAPH | HIST_FIELD_FL_PERCENT |
4249 					 HIST_FIELD_FL_BUCKET | HIST_FIELD_FL_LOG2))
4250 			goto err;
4251 	} else {
4252 		/* Value */
4253 		if (hist_field->flags & (HIST_FIELD_FL_GRAPH | HIST_FIELD_FL_PERCENT |
4254 					 HIST_FIELD_FL_BUCKET | HIST_FIELD_FL_LOG2 |
4255 					 HIST_FIELD_FL_SYM | HIST_FIELD_FL_SYM_OFFSET |
4256 					 HIST_FIELD_FL_SYSCALL | HIST_FIELD_FL_STACKTRACE))
4257 			goto err;
4258 	}
4259 
4260 	hist_data->fields[val_idx] = hist_field;
4261 
4262 	++hist_data->n_vals;
4263 	++hist_data->n_fields;
4264 
4265 	if (WARN_ON(hist_data->n_vals > TRACING_MAP_VALS_MAX + TRACING_MAP_VARS_MAX))
4266 		ret = -EINVAL;
4267  out:
4268 	return ret;
4269  err:
4270 	hist_err(file->tr, HIST_ERR_BAD_FIELD_MODIFIER, errpos(field_str));
4271 	return -EINVAL;
4272 }
4273 
4274 static int create_val_field(struct hist_trigger_data *hist_data,
4275 			    unsigned int val_idx,
4276 			    struct trace_event_file *file,
4277 			    char *field_str)
4278 {
4279 	if (WARN_ON(val_idx >= TRACING_MAP_VALS_MAX))
4280 		return -EINVAL;
4281 
4282 	return __create_val_field(hist_data, val_idx, file, NULL, field_str, 0);
4283 }
4284 
4285 static const char no_comm[] = "(no comm)";
4286 
4287 static u64 hist_field_execname(struct hist_field *hist_field,
4288 			       struct tracing_map_elt *elt,
4289 			       struct trace_buffer *buffer,
4290 			       struct ring_buffer_event *rbe,
4291 			       void *event)
4292 {
4293 	struct hist_elt_data *elt_data;
4294 
4295 	if (WARN_ON_ONCE(!elt))
4296 		return (u64)(unsigned long)no_comm;
4297 
4298 	elt_data = elt->private_data;
4299 
4300 	if (WARN_ON_ONCE(!elt_data->comm))
4301 		return (u64)(unsigned long)no_comm;
4302 
4303 	return (u64)(unsigned long)(elt_data->comm);
4304 }
4305 
4306 static u64 hist_field_stack(struct hist_field *hist_field,
4307 			    struct tracing_map_elt *elt,
4308 			    struct trace_buffer *buffer,
4309 			    struct ring_buffer_event *rbe,
4310 			    void *event)
4311 {
4312 	u32 str_item = *(u32 *)(event + hist_field->field->offset);
4313 	int str_loc = str_item & 0xffff;
4314 	char *addr = (char *)(event + str_loc);
4315 
4316 	return (u64)(unsigned long)addr;
4317 }
4318 
4319 static u64 hist_fn_call(struct hist_field *hist_field,
4320 			struct tracing_map_elt *elt,
4321 			struct trace_buffer *buffer,
4322 			struct ring_buffer_event *rbe,
4323 			void *event)
4324 {
4325 	switch (hist_field->fn_num) {
4326 	case HIST_FIELD_FN_VAR_REF:
4327 		return hist_field_var_ref(hist_field, elt, buffer, rbe, event);
4328 	case HIST_FIELD_FN_COUNTER:
4329 		return hist_field_counter(hist_field, elt, buffer, rbe, event);
4330 	case HIST_FIELD_FN_CONST:
4331 		return hist_field_const(hist_field, elt, buffer, rbe, event);
4332 	case HIST_FIELD_FN_LOG2:
4333 		return hist_field_log2(hist_field, elt, buffer, rbe, event);
4334 	case HIST_FIELD_FN_BUCKET:
4335 		return hist_field_bucket(hist_field, elt, buffer, rbe, event);
4336 	case HIST_FIELD_FN_TIMESTAMP:
4337 		return hist_field_timestamp(hist_field, elt, buffer, rbe, event);
4338 	case HIST_FIELD_FN_CPU:
4339 		return hist_field_cpu(hist_field, elt, buffer, rbe, event);
4340 	case HIST_FIELD_FN_STRING:
4341 		return hist_field_string(hist_field, elt, buffer, rbe, event);
4342 	case HIST_FIELD_FN_DYNSTRING:
4343 		return hist_field_dynstring(hist_field, elt, buffer, rbe, event);
4344 	case HIST_FIELD_FN_RELDYNSTRING:
4345 		return hist_field_reldynstring(hist_field, elt, buffer, rbe, event);
4346 	case HIST_FIELD_FN_PSTRING:
4347 		return hist_field_pstring(hist_field, elt, buffer, rbe, event);
4348 	case HIST_FIELD_FN_S64:
4349 		return hist_field_s64(hist_field, elt, buffer, rbe, event);
4350 	case HIST_FIELD_FN_U64:
4351 		return hist_field_u64(hist_field, elt, buffer, rbe, event);
4352 	case HIST_FIELD_FN_S32:
4353 		return hist_field_s32(hist_field, elt, buffer, rbe, event);
4354 	case HIST_FIELD_FN_U32:
4355 		return hist_field_u32(hist_field, elt, buffer, rbe, event);
4356 	case HIST_FIELD_FN_S16:
4357 		return hist_field_s16(hist_field, elt, buffer, rbe, event);
4358 	case HIST_FIELD_FN_U16:
4359 		return hist_field_u16(hist_field, elt, buffer, rbe, event);
4360 	case HIST_FIELD_FN_S8:
4361 		return hist_field_s8(hist_field, elt, buffer, rbe, event);
4362 	case HIST_FIELD_FN_U8:
4363 		return hist_field_u8(hist_field, elt, buffer, rbe, event);
4364 	case HIST_FIELD_FN_UMINUS:
4365 		return hist_field_unary_minus(hist_field, elt, buffer, rbe, event);
4366 	case HIST_FIELD_FN_MINUS:
4367 		return hist_field_minus(hist_field, elt, buffer, rbe, event);
4368 	case HIST_FIELD_FN_PLUS:
4369 		return hist_field_plus(hist_field, elt, buffer, rbe, event);
4370 	case HIST_FIELD_FN_DIV:
4371 		return hist_field_div(hist_field, elt, buffer, rbe, event);
4372 	case HIST_FIELD_FN_MULT:
4373 		return hist_field_mult(hist_field, elt, buffer, rbe, event);
4374 	case HIST_FIELD_FN_DIV_POWER2:
4375 		return div_by_power_of_two(hist_field, elt, buffer, rbe, event);
4376 	case HIST_FIELD_FN_DIV_NOT_POWER2:
4377 		return div_by_not_power_of_two(hist_field, elt, buffer, rbe, event);
4378 	case HIST_FIELD_FN_DIV_MULT_SHIFT:
4379 		return div_by_mult_and_shift(hist_field, elt, buffer, rbe, event);
4380 	case HIST_FIELD_FN_EXECNAME:
4381 		return hist_field_execname(hist_field, elt, buffer, rbe, event);
4382 	case HIST_FIELD_FN_STACK:
4383 		return hist_field_stack(hist_field, elt, buffer, rbe, event);
4384 	default:
4385 		return 0;
4386 	}
4387 }
4388 
4389 /* Convert a var that points to common_pid.execname to a string */
4390 static void update_var_execname(struct hist_field *hist_field)
4391 {
4392 	hist_field->flags = HIST_FIELD_FL_STRING | HIST_FIELD_FL_VAR |
4393 		HIST_FIELD_FL_EXECNAME;
4394 	hist_field->size = MAX_FILTER_STR_VAL;
4395 	hist_field->is_signed = 0;
4396 
4397 	kfree_const(hist_field->type);
4398 	hist_field->type = "char[]";
4399 
4400 	hist_field->fn_num = HIST_FIELD_FN_EXECNAME;
4401 }
4402 
4403 static int create_var_field(struct hist_trigger_data *hist_data,
4404 			    unsigned int val_idx,
4405 			    struct trace_event_file *file,
4406 			    char *var_name, char *expr_str)
4407 {
4408 	struct trace_array *tr = hist_data->event_file->tr;
4409 	unsigned long flags = 0;
4410 	int ret;
4411 
4412 	if (WARN_ON(val_idx >= TRACING_MAP_VALS_MAX + TRACING_MAP_VARS_MAX))
4413 		return -EINVAL;
4414 
4415 	if (find_var(hist_data, file, var_name) && !hist_data->remove) {
4416 		hist_err(tr, HIST_ERR_DUPLICATE_VAR, errpos(var_name));
4417 		return -EINVAL;
4418 	}
4419 
4420 	flags |= HIST_FIELD_FL_VAR;
4421 	hist_data->n_vars++;
4422 	if (WARN_ON(hist_data->n_vars > TRACING_MAP_VARS_MAX))
4423 		return -EINVAL;
4424 
4425 	ret = __create_val_field(hist_data, val_idx, file, var_name, expr_str, flags);
4426 
4427 	if (!ret && hist_data->fields[val_idx]->flags & HIST_FIELD_FL_EXECNAME)
4428 		update_var_execname(hist_data->fields[val_idx]);
4429 
4430 	if (!ret && hist_data->fields[val_idx]->flags &
4431 	    (HIST_FIELD_FL_STRING | HIST_FIELD_FL_STACKTRACE))
4432 		hist_data->fields[val_idx]->var_str_idx = hist_data->n_var_str++;
4433 
4434 	return ret;
4435 }
4436 
4437 static int create_val_fields(struct hist_trigger_data *hist_data,
4438 			     struct trace_event_file *file)
4439 {
4440 	unsigned int i, j = 1, n_hitcount = 0;
4441 	char *fields_str, *field_str;
4442 	int ret;
4443 
4444 	ret = create_hitcount_val(hist_data);
4445 	if (ret)
4446 		goto out;
4447 
4448 	fields_str = hist_data->attrs->vals_str;
4449 	if (!fields_str)
4450 		goto out;
4451 
4452 	for (i = 0, j = 1; i < TRACING_MAP_VALS_MAX &&
4453 		     j < TRACING_MAP_VALS_MAX; i++) {
4454 		field_str = strsep(&fields_str, ",");
4455 		if (!field_str)
4456 			break;
4457 
4458 		if (strcmp(field_str, "hitcount") == 0) {
4459 			if (!n_hitcount++)
4460 				continue;
4461 		}
4462 
4463 		ret = create_val_field(hist_data, j++, file, field_str);
4464 		if (ret)
4465 			goto out;
4466 	}
4467 
4468 	if (fields_str && (strcmp(fields_str, "hitcount") != 0))
4469 		ret = -EINVAL;
4470  out:
4471 	/* There is only raw hitcount but nohitcount suppresses it. */
4472 	if (j == 1 && hist_data->attrs->no_hitcount) {
4473 		hist_err(hist_data->event_file->tr, HIST_ERR_NEED_NOHC_VAL, 0);
4474 		ret = -ENOENT;
4475 	}
4476 
4477 	return ret;
4478 }
4479 
4480 static int create_key_field(struct hist_trigger_data *hist_data,
4481 			    unsigned int key_idx,
4482 			    unsigned int key_offset,
4483 			    struct trace_event_file *file,
4484 			    char *field_str)
4485 {
4486 	struct trace_array *tr = hist_data->event_file->tr;
4487 	struct hist_field *hist_field = NULL;
4488 	unsigned long flags = 0;
4489 	unsigned int key_size;
4490 	int ret = 0, n_subexprs = 0;
4491 
4492 	if (WARN_ON(key_idx >= HIST_FIELDS_MAX))
4493 		return -EINVAL;
4494 
4495 	flags |= HIST_FIELD_FL_KEY;
4496 
4497 	if (strcmp(field_str, "stacktrace") == 0) {
4498 		flags |= HIST_FIELD_FL_STACKTRACE;
4499 		key_size = sizeof(unsigned long) * HIST_STACKTRACE_DEPTH;
4500 		hist_field = create_hist_field(hist_data, NULL, flags, NULL);
4501 	} else {
4502 		hist_field = parse_expr(hist_data, file, field_str, flags,
4503 					NULL, &n_subexprs);
4504 		if (IS_ERR(hist_field)) {
4505 			ret = PTR_ERR(hist_field);
4506 			goto out;
4507 		}
4508 
4509 		if (field_has_hist_vars(hist_field, 0))	{
4510 			hist_err(tr, HIST_ERR_INVALID_REF_KEY, errpos(field_str));
4511 			destroy_hist_field(hist_field, 0);
4512 			ret = -EINVAL;
4513 			goto out;
4514 		}
4515 
4516 		key_size = hist_field->size;
4517 	}
4518 
4519 	hist_data->fields[key_idx] = hist_field;
4520 
4521 	key_size = ALIGN(key_size, sizeof(u64));
4522 	hist_data->fields[key_idx]->size = key_size;
4523 	hist_data->fields[key_idx]->offset = key_offset;
4524 
4525 	hist_data->key_size += key_size;
4526 
4527 	if (hist_data->key_size > HIST_KEY_SIZE_MAX) {
4528 		ret = -EINVAL;
4529 		goto out;
4530 	}
4531 
4532 	hist_data->n_keys++;
4533 	hist_data->n_fields++;
4534 
4535 	if (WARN_ON(hist_data->n_keys > TRACING_MAP_KEYS_MAX))
4536 		return -EINVAL;
4537 
4538 	ret = key_size;
4539  out:
4540 	return ret;
4541 }
4542 
4543 static int create_key_fields(struct hist_trigger_data *hist_data,
4544 			     struct trace_event_file *file)
4545 {
4546 	unsigned int i, key_offset = 0, n_vals = hist_data->n_vals;
4547 	char *fields_str, *field_str;
4548 	int ret = -EINVAL;
4549 
4550 	fields_str = hist_data->attrs->keys_str;
4551 	if (!fields_str)
4552 		goto out;
4553 
4554 	for (i = n_vals; i < n_vals + TRACING_MAP_KEYS_MAX; i++) {
4555 		field_str = strsep(&fields_str, ",");
4556 		if (!field_str)
4557 			break;
4558 		ret = create_key_field(hist_data, i, key_offset,
4559 				       file, field_str);
4560 		if (ret < 0)
4561 			goto out;
4562 		key_offset += ret;
4563 	}
4564 	if (fields_str) {
4565 		ret = -EINVAL;
4566 		goto out;
4567 	}
4568 	ret = 0;
4569  out:
4570 	return ret;
4571 }
4572 
4573 static int create_var_fields(struct hist_trigger_data *hist_data,
4574 			     struct trace_event_file *file)
4575 {
4576 	unsigned int i, j = hist_data->n_vals;
4577 	int ret = 0;
4578 
4579 	unsigned int n_vars = hist_data->attrs->var_defs.n_vars;
4580 
4581 	for (i = 0; i < n_vars; i++) {
4582 		char *var_name = hist_data->attrs->var_defs.name[i];
4583 		char *expr = hist_data->attrs->var_defs.expr[i];
4584 
4585 		ret = create_var_field(hist_data, j++, file, var_name, expr);
4586 		if (ret)
4587 			goto out;
4588 	}
4589  out:
4590 	return ret;
4591 }
4592 
4593 static void free_var_defs(struct hist_trigger_data *hist_data)
4594 {
4595 	unsigned int i;
4596 
4597 	for (i = 0; i < hist_data->attrs->var_defs.n_vars; i++) {
4598 		kfree(hist_data->attrs->var_defs.name[i]);
4599 		kfree(hist_data->attrs->var_defs.expr[i]);
4600 	}
4601 
4602 	hist_data->attrs->var_defs.n_vars = 0;
4603 }
4604 
4605 static int parse_var_defs(struct hist_trigger_data *hist_data)
4606 {
4607 	struct trace_array *tr = hist_data->event_file->tr;
4608 	char *s, *str, *var_name, *field_str;
4609 	unsigned int i, j, n_vars = 0;
4610 	int ret = 0;
4611 
4612 	for (i = 0; i < hist_data->attrs->n_assignments; i++) {
4613 		str = hist_data->attrs->assignment_str[i];
4614 		for (j = 0; j < TRACING_MAP_VARS_MAX; j++) {
4615 			field_str = strsep(&str, ",");
4616 			if (!field_str)
4617 				break;
4618 
4619 			var_name = strsep(&field_str, "=");
4620 			if (!var_name || !field_str) {
4621 				hist_err(tr, HIST_ERR_MALFORMED_ASSIGNMENT,
4622 					 errpos(var_name));
4623 				ret = -EINVAL;
4624 				goto free;
4625 			}
4626 
4627 			if (n_vars == TRACING_MAP_VARS_MAX) {
4628 				hist_err(tr, HIST_ERR_TOO_MANY_VARS, errpos(var_name));
4629 				ret = -EINVAL;
4630 				goto free;
4631 			}
4632 
4633 			s = kstrdup(var_name, GFP_KERNEL);
4634 			if (!s) {
4635 				ret = -ENOMEM;
4636 				goto free;
4637 			}
4638 			hist_data->attrs->var_defs.name[n_vars] = s;
4639 
4640 			s = kstrdup(field_str, GFP_KERNEL);
4641 			if (!s) {
4642 				kfree(hist_data->attrs->var_defs.name[n_vars]);
4643 				hist_data->attrs->var_defs.name[n_vars] = NULL;
4644 				ret = -ENOMEM;
4645 				goto free;
4646 			}
4647 			hist_data->attrs->var_defs.expr[n_vars++] = s;
4648 
4649 			hist_data->attrs->var_defs.n_vars = n_vars;
4650 		}
4651 	}
4652 
4653 	return ret;
4654  free:
4655 	free_var_defs(hist_data);
4656 
4657 	return ret;
4658 }
4659 
4660 static int create_hist_fields(struct hist_trigger_data *hist_data,
4661 			      struct trace_event_file *file)
4662 {
4663 	int ret;
4664 
4665 	ret = parse_var_defs(hist_data);
4666 	if (ret)
4667 		return ret;
4668 
4669 	ret = create_val_fields(hist_data, file);
4670 	if (ret)
4671 		goto out;
4672 
4673 	ret = create_var_fields(hist_data, file);
4674 	if (ret)
4675 		goto out;
4676 
4677 	ret = create_key_fields(hist_data, file);
4678 
4679  out:
4680 	free_var_defs(hist_data);
4681 
4682 	return ret;
4683 }
4684 
4685 static int is_descending(struct trace_array *tr, const char *str)
4686 {
4687 	if (!str)
4688 		return 0;
4689 
4690 	if (strcmp(str, "descending") == 0)
4691 		return 1;
4692 
4693 	if (strcmp(str, "ascending") == 0)
4694 		return 0;
4695 
4696 	hist_err(tr, HIST_ERR_INVALID_SORT_MODIFIER, errpos((char *)str));
4697 
4698 	return -EINVAL;
4699 }
4700 
4701 static int create_sort_keys(struct hist_trigger_data *hist_data)
4702 {
4703 	struct trace_array *tr = hist_data->event_file->tr;
4704 	char *fields_str = hist_data->attrs->sort_key_str;
4705 	struct tracing_map_sort_key *sort_key;
4706 	int descending, ret = 0;
4707 	unsigned int i, j, k;
4708 
4709 	hist_data->n_sort_keys = 1; /* we always have at least one, hitcount */
4710 
4711 	if (!fields_str)
4712 		goto out;
4713 
4714 	for (i = 0; i < TRACING_MAP_SORT_KEYS_MAX; i++) {
4715 		struct hist_field *hist_field;
4716 		char *field_str, *field_name;
4717 		const char *test_name;
4718 
4719 		sort_key = &hist_data->sort_keys[i];
4720 
4721 		field_str = strsep(&fields_str, ",");
4722 		if (!field_str)
4723 			break;
4724 
4725 		if (!*field_str) {
4726 			ret = -EINVAL;
4727 			hist_err(tr, HIST_ERR_EMPTY_SORT_FIELD, errpos("sort="));
4728 			break;
4729 		}
4730 
4731 		if ((i == TRACING_MAP_SORT_KEYS_MAX - 1) && fields_str) {
4732 			hist_err(tr, HIST_ERR_TOO_MANY_SORT_FIELDS, errpos("sort="));
4733 			ret = -EINVAL;
4734 			break;
4735 		}
4736 
4737 		field_name = strsep(&field_str, ".");
4738 		if (!field_name || !*field_name) {
4739 			ret = -EINVAL;
4740 			hist_err(tr, HIST_ERR_EMPTY_SORT_FIELD, errpos("sort="));
4741 			break;
4742 		}
4743 
4744 		if (strcmp(field_name, "hitcount") == 0) {
4745 			descending = is_descending(tr, field_str);
4746 			if (descending < 0) {
4747 				ret = descending;
4748 				break;
4749 			}
4750 			sort_key->descending = descending;
4751 			continue;
4752 		}
4753 
4754 		for (j = 1, k = 1; j < hist_data->n_fields; j++) {
4755 			unsigned int idx;
4756 
4757 			hist_field = hist_data->fields[j];
4758 			if (hist_field->flags & HIST_FIELD_FL_VAR)
4759 				continue;
4760 
4761 			idx = k++;
4762 
4763 			test_name = hist_field_name(hist_field, 0);
4764 
4765 			if (strcmp(field_name, test_name) == 0) {
4766 				sort_key->field_idx = idx;
4767 				descending = is_descending(tr, field_str);
4768 				if (descending < 0) {
4769 					ret = descending;
4770 					goto out;
4771 				}
4772 				sort_key->descending = descending;
4773 				break;
4774 			}
4775 		}
4776 		if (j == hist_data->n_fields) {
4777 			ret = -EINVAL;
4778 			hist_err(tr, HIST_ERR_INVALID_SORT_FIELD, errpos(field_name));
4779 			break;
4780 		}
4781 	}
4782 
4783 	hist_data->n_sort_keys = i;
4784  out:
4785 	return ret;
4786 }
4787 
4788 static void destroy_actions(struct hist_trigger_data *hist_data)
4789 {
4790 	unsigned int i;
4791 
4792 	for (i = 0; i < hist_data->n_actions; i++) {
4793 		struct action_data *data = hist_data->actions[i];
4794 
4795 		if (data->handler == HANDLER_ONMATCH)
4796 			onmatch_destroy(data);
4797 		else if (data->handler == HANDLER_ONMAX ||
4798 			 data->handler == HANDLER_ONCHANGE)
4799 			track_data_destroy(hist_data, data);
4800 		else
4801 			kfree(data);
4802 	}
4803 }
4804 
4805 static int parse_actions(struct hist_trigger_data *hist_data)
4806 {
4807 	struct trace_array *tr = hist_data->event_file->tr;
4808 	struct action_data *data;
4809 	unsigned int i;
4810 	int ret = 0;
4811 	char *str;
4812 	int len;
4813 
4814 	for (i = 0; i < hist_data->attrs->n_actions; i++) {
4815 		str = hist_data->attrs->action_str[i];
4816 
4817 		if ((len = str_has_prefix(str, "onmatch("))) {
4818 			char *action_str = str + len;
4819 
4820 			data = onmatch_parse(tr, action_str);
4821 			if (IS_ERR(data)) {
4822 				ret = PTR_ERR(data);
4823 				break;
4824 			}
4825 		} else if ((len = str_has_prefix(str, "onmax("))) {
4826 			char *action_str = str + len;
4827 
4828 			data = track_data_parse(hist_data, action_str,
4829 						HANDLER_ONMAX);
4830 			if (IS_ERR(data)) {
4831 				ret = PTR_ERR(data);
4832 				break;
4833 			}
4834 		} else if ((len = str_has_prefix(str, "onchange("))) {
4835 			char *action_str = str + len;
4836 
4837 			data = track_data_parse(hist_data, action_str,
4838 						HANDLER_ONCHANGE);
4839 			if (IS_ERR(data)) {
4840 				ret = PTR_ERR(data);
4841 				break;
4842 			}
4843 		} else {
4844 			ret = -EINVAL;
4845 			break;
4846 		}
4847 
4848 		hist_data->actions[hist_data->n_actions++] = data;
4849 	}
4850 
4851 	return ret;
4852 }
4853 
4854 static int create_actions(struct hist_trigger_data *hist_data)
4855 {
4856 	struct action_data *data;
4857 	unsigned int i;
4858 	int ret = 0;
4859 
4860 	for (i = 0; i < hist_data->attrs->n_actions; i++) {
4861 		data = hist_data->actions[i];
4862 
4863 		if (data->handler == HANDLER_ONMATCH) {
4864 			ret = onmatch_create(hist_data, data);
4865 			if (ret)
4866 				break;
4867 		} else if (data->handler == HANDLER_ONMAX ||
4868 			   data->handler == HANDLER_ONCHANGE) {
4869 			ret = track_data_create(hist_data, data);
4870 			if (ret)
4871 				break;
4872 		} else {
4873 			ret = -EINVAL;
4874 			break;
4875 		}
4876 	}
4877 
4878 	return ret;
4879 }
4880 
4881 static void print_actions(struct seq_file *m,
4882 			  struct hist_trigger_data *hist_data,
4883 			  struct tracing_map_elt *elt)
4884 {
4885 	unsigned int i;
4886 
4887 	for (i = 0; i < hist_data->n_actions; i++) {
4888 		struct action_data *data = hist_data->actions[i];
4889 
4890 		if (data->action == ACTION_SNAPSHOT)
4891 			continue;
4892 
4893 		if (data->handler == HANDLER_ONMAX ||
4894 		    data->handler == HANDLER_ONCHANGE)
4895 			track_data_print(m, hist_data, elt, data);
4896 	}
4897 }
4898 
4899 static void print_action_spec(struct seq_file *m,
4900 			      struct hist_trigger_data *hist_data,
4901 			      struct action_data *data)
4902 {
4903 	unsigned int i;
4904 
4905 	if (data->action == ACTION_SAVE) {
4906 		for (i = 0; i < hist_data->n_save_vars; i++) {
4907 			seq_printf(m, "%s", hist_data->save_vars[i]->var->var.name);
4908 			if (i < hist_data->n_save_vars - 1)
4909 				seq_puts(m, ",");
4910 		}
4911 	} else if (data->action == ACTION_TRACE) {
4912 		if (data->use_trace_keyword)
4913 			seq_printf(m, "%s", data->synth_event_name);
4914 		for (i = 0; i < data->n_params; i++) {
4915 			if (i || data->use_trace_keyword)
4916 				seq_puts(m, ",");
4917 			seq_printf(m, "%s", data->params[i]);
4918 		}
4919 	}
4920 }
4921 
4922 static void print_track_data_spec(struct seq_file *m,
4923 				  struct hist_trigger_data *hist_data,
4924 				  struct action_data *data)
4925 {
4926 	if (data->handler == HANDLER_ONMAX)
4927 		seq_puts(m, ":onmax(");
4928 	else if (data->handler == HANDLER_ONCHANGE)
4929 		seq_puts(m, ":onchange(");
4930 	seq_printf(m, "%s", data->track_data.var_str);
4931 	seq_printf(m, ").%s(", data->action_name);
4932 
4933 	print_action_spec(m, hist_data, data);
4934 
4935 	seq_puts(m, ")");
4936 }
4937 
4938 static void print_onmatch_spec(struct seq_file *m,
4939 			       struct hist_trigger_data *hist_data,
4940 			       struct action_data *data)
4941 {
4942 	seq_printf(m, ":onmatch(%s.%s).", data->match_data.event_system,
4943 		   data->match_data.event);
4944 
4945 	seq_printf(m, "%s(", data->action_name);
4946 
4947 	print_action_spec(m, hist_data, data);
4948 
4949 	seq_puts(m, ")");
4950 }
4951 
4952 static bool actions_match(struct hist_trigger_data *hist_data,
4953 			  struct hist_trigger_data *hist_data_test)
4954 {
4955 	unsigned int i, j;
4956 
4957 	if (hist_data->n_actions != hist_data_test->n_actions)
4958 		return false;
4959 
4960 	for (i = 0; i < hist_data->n_actions; i++) {
4961 		struct action_data *data = hist_data->actions[i];
4962 		struct action_data *data_test = hist_data_test->actions[i];
4963 		char *action_name, *action_name_test;
4964 
4965 		if (data->handler != data_test->handler)
4966 			return false;
4967 		if (data->action != data_test->action)
4968 			return false;
4969 
4970 		if (data->n_params != data_test->n_params)
4971 			return false;
4972 
4973 		for (j = 0; j < data->n_params; j++) {
4974 			if (strcmp(data->params[j], data_test->params[j]) != 0)
4975 				return false;
4976 		}
4977 
4978 		if (data->use_trace_keyword)
4979 			action_name = data->synth_event_name;
4980 		else
4981 			action_name = data->action_name;
4982 
4983 		if (data_test->use_trace_keyword)
4984 			action_name_test = data_test->synth_event_name;
4985 		else
4986 			action_name_test = data_test->action_name;
4987 
4988 		if (strcmp(action_name, action_name_test) != 0)
4989 			return false;
4990 
4991 		if (data->handler == HANDLER_ONMATCH) {
4992 			if (strcmp(data->match_data.event_system,
4993 				   data_test->match_data.event_system) != 0)
4994 				return false;
4995 			if (strcmp(data->match_data.event,
4996 				   data_test->match_data.event) != 0)
4997 				return false;
4998 		} else if (data->handler == HANDLER_ONMAX ||
4999 			   data->handler == HANDLER_ONCHANGE) {
5000 			if (strcmp(data->track_data.var_str,
5001 				   data_test->track_data.var_str) != 0)
5002 				return false;
5003 		}
5004 	}
5005 
5006 	return true;
5007 }
5008 
5009 
5010 static void print_actions_spec(struct seq_file *m,
5011 			       struct hist_trigger_data *hist_data)
5012 {
5013 	unsigned int i;
5014 
5015 	for (i = 0; i < hist_data->n_actions; i++) {
5016 		struct action_data *data = hist_data->actions[i];
5017 
5018 		if (data->handler == HANDLER_ONMATCH)
5019 			print_onmatch_spec(m, hist_data, data);
5020 		else if (data->handler == HANDLER_ONMAX ||
5021 			 data->handler == HANDLER_ONCHANGE)
5022 			print_track_data_spec(m, hist_data, data);
5023 	}
5024 }
5025 
5026 static void destroy_field_var_hists(struct hist_trigger_data *hist_data)
5027 {
5028 	unsigned int i;
5029 
5030 	for (i = 0; i < hist_data->n_field_var_hists; i++) {
5031 		kfree(hist_data->field_var_hists[i]->cmd);
5032 		kfree(hist_data->field_var_hists[i]);
5033 	}
5034 }
5035 
5036 static void destroy_hist_data(struct hist_trigger_data *hist_data)
5037 {
5038 	if (!hist_data)
5039 		return;
5040 
5041 	destroy_hist_trigger_attrs(hist_data->attrs);
5042 	destroy_hist_fields(hist_data);
5043 	tracing_map_destroy(hist_data->map);
5044 
5045 	destroy_actions(hist_data);
5046 	destroy_field_vars(hist_data);
5047 	destroy_field_var_hists(hist_data);
5048 
5049 	kfree(hist_data);
5050 }
5051 
5052 static int create_tracing_map_fields(struct hist_trigger_data *hist_data)
5053 {
5054 	struct tracing_map *map = hist_data->map;
5055 	struct ftrace_event_field *field;
5056 	struct hist_field *hist_field;
5057 	int i, idx = 0;
5058 
5059 	for_each_hist_field(i, hist_data) {
5060 		hist_field = hist_data->fields[i];
5061 		if (hist_field->flags & HIST_FIELD_FL_KEY) {
5062 			tracing_map_cmp_fn_t cmp_fn;
5063 
5064 			field = hist_field->field;
5065 
5066 			if (hist_field->flags & HIST_FIELD_FL_STACKTRACE)
5067 				cmp_fn = tracing_map_cmp_none;
5068 			else if (!field || hist_field->flags & HIST_FIELD_FL_CPU)
5069 				cmp_fn = tracing_map_cmp_num(hist_field->size,
5070 							     hist_field->is_signed);
5071 			else if (is_string_field(field))
5072 				cmp_fn = tracing_map_cmp_string;
5073 			else
5074 				cmp_fn = tracing_map_cmp_num(field->size,
5075 							     field->is_signed);
5076 			idx = tracing_map_add_key_field(map,
5077 							hist_field->offset,
5078 							cmp_fn);
5079 		} else if (!(hist_field->flags & HIST_FIELD_FL_VAR))
5080 			idx = tracing_map_add_sum_field(map);
5081 
5082 		if (idx < 0)
5083 			return idx;
5084 
5085 		if (hist_field->flags & HIST_FIELD_FL_VAR) {
5086 			idx = tracing_map_add_var(map);
5087 			if (idx < 0)
5088 				return idx;
5089 			hist_field->var.idx = idx;
5090 			hist_field->var.hist_data = hist_data;
5091 		}
5092 	}
5093 
5094 	return 0;
5095 }
5096 
5097 static struct hist_trigger_data *
5098 create_hist_data(unsigned int map_bits,
5099 		 struct hist_trigger_attrs *attrs,
5100 		 struct trace_event_file *file,
5101 		 bool remove)
5102 {
5103 	const struct tracing_map_ops *map_ops = NULL;
5104 	struct hist_trigger_data *hist_data;
5105 	int ret = 0;
5106 
5107 	hist_data = kzalloc(sizeof(*hist_data), GFP_KERNEL);
5108 	if (!hist_data)
5109 		return ERR_PTR(-ENOMEM);
5110 
5111 	hist_data->attrs = attrs;
5112 	hist_data->remove = remove;
5113 	hist_data->event_file = file;
5114 
5115 	ret = parse_actions(hist_data);
5116 	if (ret)
5117 		goto free;
5118 
5119 	ret = create_hist_fields(hist_data, file);
5120 	if (ret)
5121 		goto free;
5122 
5123 	ret = create_sort_keys(hist_data);
5124 	if (ret)
5125 		goto free;
5126 
5127 	map_ops = &hist_trigger_elt_data_ops;
5128 
5129 	hist_data->map = tracing_map_create(map_bits, hist_data->key_size,
5130 					    map_ops, hist_data);
5131 	if (IS_ERR(hist_data->map)) {
5132 		ret = PTR_ERR(hist_data->map);
5133 		hist_data->map = NULL;
5134 		goto free;
5135 	}
5136 
5137 	ret = create_tracing_map_fields(hist_data);
5138 	if (ret)
5139 		goto free;
5140  out:
5141 	return hist_data;
5142  free:
5143 	hist_data->attrs = NULL;
5144 
5145 	destroy_hist_data(hist_data);
5146 
5147 	hist_data = ERR_PTR(ret);
5148 
5149 	goto out;
5150 }
5151 
5152 static void hist_trigger_elt_update(struct hist_trigger_data *hist_data,
5153 				    struct tracing_map_elt *elt,
5154 				    struct trace_buffer *buffer, void *rec,
5155 				    struct ring_buffer_event *rbe,
5156 				    u64 *var_ref_vals)
5157 {
5158 	struct hist_elt_data *elt_data;
5159 	struct hist_field *hist_field;
5160 	unsigned int i, var_idx;
5161 	u64 hist_val;
5162 
5163 	elt_data = elt->private_data;
5164 	elt_data->var_ref_vals = var_ref_vals;
5165 
5166 	for_each_hist_val_field(i, hist_data) {
5167 		hist_field = hist_data->fields[i];
5168 		hist_val = hist_fn_call(hist_field, elt, buffer, rbe, rec);
5169 		if (hist_field->flags & HIST_FIELD_FL_VAR) {
5170 			var_idx = hist_field->var.idx;
5171 
5172 			if (hist_field->flags &
5173 			    (HIST_FIELD_FL_STRING | HIST_FIELD_FL_STACKTRACE)) {
5174 				unsigned int str_start, var_str_idx, idx;
5175 				char *str, *val_str;
5176 				unsigned int size;
5177 
5178 				str_start = hist_data->n_field_var_str +
5179 					hist_data->n_save_var_str;
5180 				var_str_idx = hist_field->var_str_idx;
5181 				idx = str_start + var_str_idx;
5182 
5183 				str = elt_data->field_var_str[idx];
5184 				val_str = (char *)(uintptr_t)hist_val;
5185 
5186 				if (hist_field->flags & HIST_FIELD_FL_STRING) {
5187 					size = min(hist_field->size, STR_VAR_LEN_MAX);
5188 					strscpy(str, val_str, size);
5189 				} else {
5190 					char *stack_start = str + sizeof(unsigned long);
5191 					int e;
5192 
5193 					e = stack_trace_save((void *)stack_start,
5194 							     HIST_STACKTRACE_DEPTH,
5195 							     HIST_STACKTRACE_SKIP);
5196 					if (e < HIST_STACKTRACE_DEPTH - 1)
5197 						((unsigned long *)stack_start)[e] = 0;
5198 					*((unsigned long *)str) = e;
5199 				}
5200 				hist_val = (u64)(uintptr_t)str;
5201 			}
5202 			tracing_map_set_var(elt, var_idx, hist_val);
5203 			continue;
5204 		}
5205 		tracing_map_update_sum(elt, i, hist_val);
5206 	}
5207 
5208 	for_each_hist_key_field(i, hist_data) {
5209 		hist_field = hist_data->fields[i];
5210 		if (hist_field->flags & HIST_FIELD_FL_VAR) {
5211 			hist_val = hist_fn_call(hist_field, elt, buffer, rbe, rec);
5212 			var_idx = hist_field->var.idx;
5213 			tracing_map_set_var(elt, var_idx, hist_val);
5214 		}
5215 	}
5216 
5217 	update_field_vars(hist_data, elt, buffer, rbe, rec);
5218 }
5219 
5220 static inline void add_to_key(char *compound_key, void *key,
5221 			      struct hist_field *key_field, void *rec)
5222 {
5223 	size_t size = key_field->size;
5224 
5225 	if (key_field->flags & HIST_FIELD_FL_STRING) {
5226 		struct ftrace_event_field *field;
5227 
5228 		field = key_field->field;
5229 		if (field->filter_type == FILTER_DYN_STRING ||
5230 		    field->filter_type == FILTER_RDYN_STRING)
5231 			size = *(u32 *)(rec + field->offset) >> 16;
5232 		else if (field->filter_type == FILTER_STATIC_STRING)
5233 			size = field->size;
5234 
5235 		/* ensure NULL-termination */
5236 		if (size > key_field->size - 1)
5237 			size = key_field->size - 1;
5238 
5239 		strncpy(compound_key + key_field->offset, (char *)key, size);
5240 	} else
5241 		memcpy(compound_key + key_field->offset, key, size);
5242 }
5243 
5244 static void
5245 hist_trigger_actions(struct hist_trigger_data *hist_data,
5246 		     struct tracing_map_elt *elt,
5247 		     struct trace_buffer *buffer, void *rec,
5248 		     struct ring_buffer_event *rbe, void *key,
5249 		     u64 *var_ref_vals)
5250 {
5251 	struct action_data *data;
5252 	unsigned int i;
5253 
5254 	for (i = 0; i < hist_data->n_actions; i++) {
5255 		data = hist_data->actions[i];
5256 		data->fn(hist_data, elt, buffer, rec, rbe, key, data, var_ref_vals);
5257 	}
5258 }
5259 
5260 static void event_hist_trigger(struct event_trigger_data *data,
5261 			       struct trace_buffer *buffer, void *rec,
5262 			       struct ring_buffer_event *rbe)
5263 {
5264 	struct hist_trigger_data *hist_data = data->private_data;
5265 	bool use_compound_key = (hist_data->n_keys > 1);
5266 	unsigned long entries[HIST_STACKTRACE_DEPTH];
5267 	u64 var_ref_vals[TRACING_MAP_VARS_MAX];
5268 	char compound_key[HIST_KEY_SIZE_MAX];
5269 	struct tracing_map_elt *elt = NULL;
5270 	struct hist_field *key_field;
5271 	u64 field_contents;
5272 	void *key = NULL;
5273 	unsigned int i;
5274 
5275 	if (unlikely(!rbe))
5276 		return;
5277 
5278 	memset(compound_key, 0, hist_data->key_size);
5279 
5280 	for_each_hist_key_field(i, hist_data) {
5281 		key_field = hist_data->fields[i];
5282 
5283 		if (key_field->flags & HIST_FIELD_FL_STACKTRACE) {
5284 			memset(entries, 0, HIST_STACKTRACE_SIZE);
5285 			if (key_field->field) {
5286 				unsigned long *stack, n_entries;
5287 
5288 				field_contents = hist_fn_call(key_field, elt, buffer, rbe, rec);
5289 				stack = (unsigned long *)(long)field_contents;
5290 				n_entries = *stack;
5291 				memcpy(entries, ++stack, n_entries * sizeof(unsigned long));
5292 			} else {
5293 				stack_trace_save(entries, HIST_STACKTRACE_DEPTH,
5294 						 HIST_STACKTRACE_SKIP);
5295 			}
5296 			key = entries;
5297 		} else {
5298 			field_contents = hist_fn_call(key_field, elt, buffer, rbe, rec);
5299 			if (key_field->flags & HIST_FIELD_FL_STRING) {
5300 				key = (void *)(unsigned long)field_contents;
5301 				use_compound_key = true;
5302 			} else
5303 				key = (void *)&field_contents;
5304 		}
5305 
5306 		if (use_compound_key)
5307 			add_to_key(compound_key, key, key_field, rec);
5308 	}
5309 
5310 	if (use_compound_key)
5311 		key = compound_key;
5312 
5313 	if (hist_data->n_var_refs &&
5314 	    !resolve_var_refs(hist_data, key, var_ref_vals, false))
5315 		return;
5316 
5317 	elt = tracing_map_insert(hist_data->map, key);
5318 	if (!elt)
5319 		return;
5320 
5321 	hist_trigger_elt_update(hist_data, elt, buffer, rec, rbe, var_ref_vals);
5322 
5323 	if (resolve_var_refs(hist_data, key, var_ref_vals, true))
5324 		hist_trigger_actions(hist_data, elt, buffer, rec, rbe, key, var_ref_vals);
5325 }
5326 
5327 static void hist_trigger_stacktrace_print(struct seq_file *m,
5328 					  unsigned long *stacktrace_entries,
5329 					  unsigned int max_entries)
5330 {
5331 	unsigned int spaces = 8;
5332 	unsigned int i;
5333 
5334 	for (i = 0; i < max_entries; i++) {
5335 		if (!stacktrace_entries[i])
5336 			return;
5337 
5338 		seq_printf(m, "%*c", 1 + spaces, ' ');
5339 		seq_printf(m, "%pS\n", (void*)stacktrace_entries[i]);
5340 	}
5341 }
5342 
5343 static void hist_trigger_print_key(struct seq_file *m,
5344 				   struct hist_trigger_data *hist_data,
5345 				   void *key,
5346 				   struct tracing_map_elt *elt)
5347 {
5348 	struct hist_field *key_field;
5349 	bool multiline = false;
5350 	const char *field_name;
5351 	unsigned int i;
5352 	u64 uval;
5353 
5354 	seq_puts(m, "{ ");
5355 
5356 	for_each_hist_key_field(i, hist_data) {
5357 		key_field = hist_data->fields[i];
5358 
5359 		if (i > hist_data->n_vals)
5360 			seq_puts(m, ", ");
5361 
5362 		field_name = hist_field_name(key_field, 0);
5363 
5364 		if (key_field->flags & HIST_FIELD_FL_HEX) {
5365 			uval = *(u64 *)(key + key_field->offset);
5366 			seq_printf(m, "%s: %llx", field_name, uval);
5367 		} else if (key_field->flags & HIST_FIELD_FL_SYM) {
5368 			uval = *(u64 *)(key + key_field->offset);
5369 			seq_printf(m, "%s: [%llx] %-45ps", field_name,
5370 				   uval, (void *)(uintptr_t)uval);
5371 		} else if (key_field->flags & HIST_FIELD_FL_SYM_OFFSET) {
5372 			uval = *(u64 *)(key + key_field->offset);
5373 			seq_printf(m, "%s: [%llx] %-55pS", field_name,
5374 				   uval, (void *)(uintptr_t)uval);
5375 		} else if (key_field->flags & HIST_FIELD_FL_EXECNAME) {
5376 			struct hist_elt_data *elt_data = elt->private_data;
5377 			char *comm;
5378 
5379 			if (WARN_ON_ONCE(!elt_data))
5380 				return;
5381 
5382 			comm = elt_data->comm;
5383 
5384 			uval = *(u64 *)(key + key_field->offset);
5385 			seq_printf(m, "%s: %-16s[%10llu]", field_name,
5386 				   comm, uval);
5387 		} else if (key_field->flags & HIST_FIELD_FL_SYSCALL) {
5388 			const char *syscall_name;
5389 
5390 			uval = *(u64 *)(key + key_field->offset);
5391 			syscall_name = get_syscall_name(uval);
5392 			if (!syscall_name)
5393 				syscall_name = "unknown_syscall";
5394 
5395 			seq_printf(m, "%s: %-30s[%3llu]", field_name,
5396 				   syscall_name, uval);
5397 		} else if (key_field->flags & HIST_FIELD_FL_STACKTRACE) {
5398 			if (key_field->field)
5399 				seq_printf(m, "%s.stacktrace", key_field->field->name);
5400 			else
5401 				seq_puts(m, "common_stacktrace:\n");
5402 			hist_trigger_stacktrace_print(m,
5403 						      key + key_field->offset,
5404 						      HIST_STACKTRACE_DEPTH);
5405 			multiline = true;
5406 		} else if (key_field->flags & HIST_FIELD_FL_LOG2) {
5407 			seq_printf(m, "%s: ~ 2^%-2llu", field_name,
5408 				   *(u64 *)(key + key_field->offset));
5409 		} else if (key_field->flags & HIST_FIELD_FL_BUCKET) {
5410 			unsigned long buckets = key_field->buckets;
5411 			uval = *(u64 *)(key + key_field->offset);
5412 			seq_printf(m, "%s: ~ %llu-%llu", field_name,
5413 				   uval, uval + buckets -1);
5414 		} else if (key_field->flags & HIST_FIELD_FL_STRING) {
5415 			seq_printf(m, "%s: %-50s", field_name,
5416 				   (char *)(key + key_field->offset));
5417 		} else {
5418 			uval = *(u64 *)(key + key_field->offset);
5419 			seq_printf(m, "%s: %10llu", field_name, uval);
5420 		}
5421 	}
5422 
5423 	if (!multiline)
5424 		seq_puts(m, " ");
5425 
5426 	seq_puts(m, "}");
5427 }
5428 
5429 /* Get the 100 times of the percentage of @val in @total */
5430 static inline unsigned int __get_percentage(u64 val, u64 total)
5431 {
5432 	if (!total)
5433 		goto div0;
5434 
5435 	if (val < (U64_MAX / 10000))
5436 		return (unsigned int)div64_ul(val * 10000, total);
5437 
5438 	total = div64_u64(total, 10000);
5439 	if (!total)
5440 		goto div0;
5441 
5442 	return (unsigned int)div64_ul(val, total);
5443 div0:
5444 	return val ? UINT_MAX : 0;
5445 }
5446 
5447 #define BAR_CHAR '#'
5448 
5449 static inline const char *__fill_bar_str(char *buf, int size, u64 val, u64 max)
5450 {
5451 	unsigned int len = __get_percentage(val, max);
5452 	int i;
5453 
5454 	if (len == UINT_MAX) {
5455 		snprintf(buf, size, "[ERROR]");
5456 		return buf;
5457 	}
5458 
5459 	len = len * size / 10000;
5460 	for (i = 0; i < len && i < size; i++)
5461 		buf[i] = BAR_CHAR;
5462 	while (i < size)
5463 		buf[i++] = ' ';
5464 	buf[size] = '\0';
5465 
5466 	return buf;
5467 }
5468 
5469 struct hist_val_stat {
5470 	u64 max;
5471 	u64 total;
5472 };
5473 
5474 static void hist_trigger_print_val(struct seq_file *m, unsigned int idx,
5475 				   const char *field_name, unsigned long flags,
5476 				   struct hist_val_stat *stats,
5477 				   struct tracing_map_elt *elt)
5478 {
5479 	u64 val = tracing_map_read_sum(elt, idx);
5480 	unsigned int pc;
5481 	char bar[21];
5482 
5483 	if (flags & HIST_FIELD_FL_PERCENT) {
5484 		pc = __get_percentage(val, stats[idx].total);
5485 		if (pc == UINT_MAX)
5486 			seq_printf(m, " %s (%%):[ERROR]", field_name);
5487 		else
5488 			seq_printf(m, " %s (%%): %3u.%02u", field_name,
5489 					pc / 100, pc % 100);
5490 	} else if (flags & HIST_FIELD_FL_GRAPH) {
5491 		seq_printf(m, " %s: %20s", field_name,
5492 			   __fill_bar_str(bar, 20, val, stats[idx].max));
5493 	} else if (flags & HIST_FIELD_FL_HEX) {
5494 		seq_printf(m, " %s: %10llx", field_name, val);
5495 	} else {
5496 		seq_printf(m, " %s: %10llu", field_name, val);
5497 	}
5498 }
5499 
5500 static void hist_trigger_entry_print(struct seq_file *m,
5501 				     struct hist_trigger_data *hist_data,
5502 				     struct hist_val_stat *stats,
5503 				     void *key,
5504 				     struct tracing_map_elt *elt)
5505 {
5506 	const char *field_name;
5507 	unsigned int i = HITCOUNT_IDX;
5508 	unsigned long flags;
5509 
5510 	hist_trigger_print_key(m, hist_data, key, elt);
5511 
5512 	/* At first, show the raw hitcount if !nohitcount */
5513 	if (!hist_data->attrs->no_hitcount)
5514 		hist_trigger_print_val(m, i, "hitcount", 0, stats, elt);
5515 
5516 	for (i = 1; i < hist_data->n_vals; i++) {
5517 		field_name = hist_field_name(hist_data->fields[i], 0);
5518 		flags = hist_data->fields[i]->flags;
5519 		if (flags & HIST_FIELD_FL_VAR || flags & HIST_FIELD_FL_EXPR)
5520 			continue;
5521 
5522 		seq_puts(m, " ");
5523 		hist_trigger_print_val(m, i, field_name, flags, stats, elt);
5524 	}
5525 
5526 	print_actions(m, hist_data, elt);
5527 
5528 	seq_puts(m, "\n");
5529 }
5530 
5531 static int print_entries(struct seq_file *m,
5532 			 struct hist_trigger_data *hist_data)
5533 {
5534 	struct tracing_map_sort_entry **sort_entries = NULL;
5535 	struct tracing_map *map = hist_data->map;
5536 	int i, j, n_entries;
5537 	struct hist_val_stat *stats = NULL;
5538 	u64 val;
5539 
5540 	n_entries = tracing_map_sort_entries(map, hist_data->sort_keys,
5541 					     hist_data->n_sort_keys,
5542 					     &sort_entries);
5543 	if (n_entries < 0)
5544 		return n_entries;
5545 
5546 	/* Calculate the max and the total for each field if needed. */
5547 	for (j = 0; j < hist_data->n_vals; j++) {
5548 		if (!(hist_data->fields[j]->flags &
5549 			(HIST_FIELD_FL_PERCENT | HIST_FIELD_FL_GRAPH)))
5550 			continue;
5551 		if (!stats) {
5552 			stats = kcalloc(hist_data->n_vals, sizeof(*stats),
5553 				       GFP_KERNEL);
5554 			if (!stats) {
5555 				n_entries = -ENOMEM;
5556 				goto out;
5557 			}
5558 		}
5559 		for (i = 0; i < n_entries; i++) {
5560 			val = tracing_map_read_sum(sort_entries[i]->elt, j);
5561 			stats[j].total += val;
5562 			if (stats[j].max < val)
5563 				stats[j].max = val;
5564 		}
5565 	}
5566 
5567 	for (i = 0; i < n_entries; i++)
5568 		hist_trigger_entry_print(m, hist_data, stats,
5569 					 sort_entries[i]->key,
5570 					 sort_entries[i]->elt);
5571 
5572 	kfree(stats);
5573 out:
5574 	tracing_map_destroy_sort_entries(sort_entries, n_entries);
5575 
5576 	return n_entries;
5577 }
5578 
5579 static void hist_trigger_show(struct seq_file *m,
5580 			      struct event_trigger_data *data, int n)
5581 {
5582 	struct hist_trigger_data *hist_data;
5583 	int n_entries;
5584 
5585 	if (n > 0)
5586 		seq_puts(m, "\n\n");
5587 
5588 	seq_puts(m, "# event histogram\n#\n# trigger info: ");
5589 	data->ops->print(m, data);
5590 	seq_puts(m, "#\n\n");
5591 
5592 	hist_data = data->private_data;
5593 	n_entries = print_entries(m, hist_data);
5594 	if (n_entries < 0)
5595 		n_entries = 0;
5596 
5597 	track_data_snapshot_print(m, hist_data);
5598 
5599 	seq_printf(m, "\nTotals:\n    Hits: %llu\n    Entries: %u\n    Dropped: %llu\n",
5600 		   (u64)atomic64_read(&hist_data->map->hits),
5601 		   n_entries, (u64)atomic64_read(&hist_data->map->drops));
5602 }
5603 
5604 static int hist_show(struct seq_file *m, void *v)
5605 {
5606 	struct event_trigger_data *data;
5607 	struct trace_event_file *event_file;
5608 	int n = 0, ret = 0;
5609 
5610 	mutex_lock(&event_mutex);
5611 
5612 	event_file = event_file_data(m->private);
5613 	if (unlikely(!event_file)) {
5614 		ret = -ENODEV;
5615 		goto out_unlock;
5616 	}
5617 
5618 	list_for_each_entry(data, &event_file->triggers, list) {
5619 		if (data->cmd_ops->trigger_type == ETT_EVENT_HIST)
5620 			hist_trigger_show(m, data, n++);
5621 	}
5622 
5623  out_unlock:
5624 	mutex_unlock(&event_mutex);
5625 
5626 	return ret;
5627 }
5628 
5629 static int event_hist_open(struct inode *inode, struct file *file)
5630 {
5631 	int ret;
5632 
5633 	ret = security_locked_down(LOCKDOWN_TRACEFS);
5634 	if (ret)
5635 		return ret;
5636 
5637 	return single_open(file, hist_show, file);
5638 }
5639 
5640 const struct file_operations event_hist_fops = {
5641 	.open = event_hist_open,
5642 	.read = seq_read,
5643 	.llseek = seq_lseek,
5644 	.release = single_release,
5645 };
5646 
5647 #ifdef CONFIG_HIST_TRIGGERS_DEBUG
5648 static void hist_field_debug_show_flags(struct seq_file *m,
5649 					unsigned long flags)
5650 {
5651 	seq_puts(m, "      flags:\n");
5652 
5653 	if (flags & HIST_FIELD_FL_KEY)
5654 		seq_puts(m, "        HIST_FIELD_FL_KEY\n");
5655 	else if (flags & HIST_FIELD_FL_HITCOUNT)
5656 		seq_puts(m, "        VAL: HIST_FIELD_FL_HITCOUNT\n");
5657 	else if (flags & HIST_FIELD_FL_VAR)
5658 		seq_puts(m, "        HIST_FIELD_FL_VAR\n");
5659 	else if (flags & HIST_FIELD_FL_VAR_REF)
5660 		seq_puts(m, "        HIST_FIELD_FL_VAR_REF\n");
5661 	else
5662 		seq_puts(m, "        VAL: normal u64 value\n");
5663 
5664 	if (flags & HIST_FIELD_FL_ALIAS)
5665 		seq_puts(m, "        HIST_FIELD_FL_ALIAS\n");
5666 	else if (flags & HIST_FIELD_FL_CONST)
5667 		seq_puts(m, "        HIST_FIELD_FL_CONST\n");
5668 }
5669 
5670 static int hist_field_debug_show(struct seq_file *m,
5671 				 struct hist_field *field, unsigned long flags)
5672 {
5673 	if ((field->flags & flags) != flags) {
5674 		seq_printf(m, "ERROR: bad flags - %lx\n", flags);
5675 		return -EINVAL;
5676 	}
5677 
5678 	hist_field_debug_show_flags(m, field->flags);
5679 	if (field->field)
5680 		seq_printf(m, "      ftrace_event_field name: %s\n",
5681 			   field->field->name);
5682 
5683 	if (field->flags & HIST_FIELD_FL_VAR) {
5684 		seq_printf(m, "      var.name: %s\n", field->var.name);
5685 		seq_printf(m, "      var.idx (into tracing_map_elt.vars[]): %u\n",
5686 			   field->var.idx);
5687 	}
5688 
5689 	if (field->flags & HIST_FIELD_FL_CONST)
5690 		seq_printf(m, "      constant: %llu\n", field->constant);
5691 
5692 	if (field->flags & HIST_FIELD_FL_ALIAS)
5693 		seq_printf(m, "      var_ref_idx (into hist_data->var_refs[]): %u\n",
5694 			   field->var_ref_idx);
5695 
5696 	if (field->flags & HIST_FIELD_FL_VAR_REF) {
5697 		seq_printf(m, "      name: %s\n", field->name);
5698 		seq_printf(m, "      var.idx (into tracing_map_elt.vars[]): %u\n",
5699 			   field->var.idx);
5700 		seq_printf(m, "      var.hist_data: %p\n", field->var.hist_data);
5701 		seq_printf(m, "      var_ref_idx (into hist_data->var_refs[]): %u\n",
5702 			   field->var_ref_idx);
5703 		if (field->system)
5704 			seq_printf(m, "      system: %s\n", field->system);
5705 		if (field->event_name)
5706 			seq_printf(m, "      event_name: %s\n", field->event_name);
5707 	}
5708 
5709 	seq_printf(m, "      type: %s\n", field->type);
5710 	seq_printf(m, "      size: %u\n", field->size);
5711 	seq_printf(m, "      is_signed: %u\n", field->is_signed);
5712 
5713 	return 0;
5714 }
5715 
5716 static int field_var_debug_show(struct seq_file *m,
5717 				struct field_var *field_var, unsigned int i,
5718 				bool save_vars)
5719 {
5720 	const char *vars_name = save_vars ? "save_vars" : "field_vars";
5721 	struct hist_field *field;
5722 	int ret = 0;
5723 
5724 	seq_printf(m, "\n    hist_data->%s[%d]:\n", vars_name, i);
5725 
5726 	field = field_var->var;
5727 
5728 	seq_printf(m, "\n      %s[%d].var:\n", vars_name, i);
5729 
5730 	hist_field_debug_show_flags(m, field->flags);
5731 	seq_printf(m, "      var.name: %s\n", field->var.name);
5732 	seq_printf(m, "      var.idx (into tracing_map_elt.vars[]): %u\n",
5733 		   field->var.idx);
5734 
5735 	field = field_var->val;
5736 
5737 	seq_printf(m, "\n      %s[%d].val:\n", vars_name, i);
5738 	if (field->field)
5739 		seq_printf(m, "      ftrace_event_field name: %s\n",
5740 			   field->field->name);
5741 	else {
5742 		ret = -EINVAL;
5743 		goto out;
5744 	}
5745 
5746 	seq_printf(m, "      type: %s\n", field->type);
5747 	seq_printf(m, "      size: %u\n", field->size);
5748 	seq_printf(m, "      is_signed: %u\n", field->is_signed);
5749 out:
5750 	return ret;
5751 }
5752 
5753 static int hist_action_debug_show(struct seq_file *m,
5754 				  struct action_data *data, int i)
5755 {
5756 	int ret = 0;
5757 
5758 	if (data->handler == HANDLER_ONMAX ||
5759 	    data->handler == HANDLER_ONCHANGE) {
5760 		seq_printf(m, "\n    hist_data->actions[%d].track_data.var_ref:\n", i);
5761 		ret = hist_field_debug_show(m, data->track_data.var_ref,
5762 					    HIST_FIELD_FL_VAR_REF);
5763 		if (ret)
5764 			goto out;
5765 
5766 		seq_printf(m, "\n    hist_data->actions[%d].track_data.track_var:\n", i);
5767 		ret = hist_field_debug_show(m, data->track_data.track_var,
5768 					    HIST_FIELD_FL_VAR);
5769 		if (ret)
5770 			goto out;
5771 	}
5772 
5773 	if (data->handler == HANDLER_ONMATCH) {
5774 		seq_printf(m, "\n    hist_data->actions[%d].match_data.event_system: %s\n",
5775 			   i, data->match_data.event_system);
5776 		seq_printf(m, "    hist_data->actions[%d].match_data.event: %s\n",
5777 			   i, data->match_data.event);
5778 	}
5779 out:
5780 	return ret;
5781 }
5782 
5783 static int hist_actions_debug_show(struct seq_file *m,
5784 				   struct hist_trigger_data *hist_data)
5785 {
5786 	int i, ret = 0;
5787 
5788 	if (hist_data->n_actions)
5789 		seq_puts(m, "\n  action tracking variables (for onmax()/onchange()/onmatch()):\n");
5790 
5791 	for (i = 0; i < hist_data->n_actions; i++) {
5792 		struct action_data *action = hist_data->actions[i];
5793 
5794 		ret = hist_action_debug_show(m, action, i);
5795 		if (ret)
5796 			goto out;
5797 	}
5798 
5799 	if (hist_data->n_save_vars)
5800 		seq_puts(m, "\n  save action variables (save() params):\n");
5801 
5802 	for (i = 0; i < hist_data->n_save_vars; i++) {
5803 		ret = field_var_debug_show(m, hist_data->save_vars[i], i, true);
5804 		if (ret)
5805 			goto out;
5806 	}
5807 out:
5808 	return ret;
5809 }
5810 
5811 static void hist_trigger_debug_show(struct seq_file *m,
5812 				    struct event_trigger_data *data, int n)
5813 {
5814 	struct hist_trigger_data *hist_data;
5815 	int i, ret;
5816 
5817 	if (n > 0)
5818 		seq_puts(m, "\n\n");
5819 
5820 	seq_puts(m, "# event histogram\n#\n# trigger info: ");
5821 	data->ops->print(m, data);
5822 	seq_puts(m, "#\n\n");
5823 
5824 	hist_data = data->private_data;
5825 
5826 	seq_printf(m, "hist_data: %p\n\n", hist_data);
5827 	seq_printf(m, "  n_vals: %u\n", hist_data->n_vals);
5828 	seq_printf(m, "  n_keys: %u\n", hist_data->n_keys);
5829 	seq_printf(m, "  n_fields: %u\n", hist_data->n_fields);
5830 
5831 	seq_puts(m, "\n  val fields:\n\n");
5832 
5833 	seq_puts(m, "    hist_data->fields[0]:\n");
5834 	ret = hist_field_debug_show(m, hist_data->fields[0],
5835 				    HIST_FIELD_FL_HITCOUNT);
5836 	if (ret)
5837 		return;
5838 
5839 	for (i = 1; i < hist_data->n_vals; i++) {
5840 		seq_printf(m, "\n    hist_data->fields[%d]:\n", i);
5841 		ret = hist_field_debug_show(m, hist_data->fields[i], 0);
5842 		if (ret)
5843 			return;
5844 	}
5845 
5846 	seq_puts(m, "\n  key fields:\n");
5847 
5848 	for (i = hist_data->n_vals; i < hist_data->n_fields; i++) {
5849 		seq_printf(m, "\n    hist_data->fields[%d]:\n", i);
5850 		ret = hist_field_debug_show(m, hist_data->fields[i],
5851 					    HIST_FIELD_FL_KEY);
5852 		if (ret)
5853 			return;
5854 	}
5855 
5856 	if (hist_data->n_var_refs)
5857 		seq_puts(m, "\n  variable reference fields:\n");
5858 
5859 	for (i = 0; i < hist_data->n_var_refs; i++) {
5860 		seq_printf(m, "\n    hist_data->var_refs[%d]:\n", i);
5861 		ret = hist_field_debug_show(m, hist_data->var_refs[i],
5862 					    HIST_FIELD_FL_VAR_REF);
5863 		if (ret)
5864 			return;
5865 	}
5866 
5867 	if (hist_data->n_field_vars)
5868 		seq_puts(m, "\n  field variables:\n");
5869 
5870 	for (i = 0; i < hist_data->n_field_vars; i++) {
5871 		ret = field_var_debug_show(m, hist_data->field_vars[i], i, false);
5872 		if (ret)
5873 			return;
5874 	}
5875 
5876 	ret = hist_actions_debug_show(m, hist_data);
5877 	if (ret)
5878 		return;
5879 }
5880 
5881 static int hist_debug_show(struct seq_file *m, void *v)
5882 {
5883 	struct event_trigger_data *data;
5884 	struct trace_event_file *event_file;
5885 	int n = 0, ret = 0;
5886 
5887 	mutex_lock(&event_mutex);
5888 
5889 	event_file = event_file_data(m->private);
5890 	if (unlikely(!event_file)) {
5891 		ret = -ENODEV;
5892 		goto out_unlock;
5893 	}
5894 
5895 	list_for_each_entry(data, &event_file->triggers, list) {
5896 		if (data->cmd_ops->trigger_type == ETT_EVENT_HIST)
5897 			hist_trigger_debug_show(m, data, n++);
5898 	}
5899 
5900  out_unlock:
5901 	mutex_unlock(&event_mutex);
5902 
5903 	return ret;
5904 }
5905 
5906 static int event_hist_debug_open(struct inode *inode, struct file *file)
5907 {
5908 	int ret;
5909 
5910 	ret = security_locked_down(LOCKDOWN_TRACEFS);
5911 	if (ret)
5912 		return ret;
5913 
5914 	return single_open(file, hist_debug_show, file);
5915 }
5916 
5917 const struct file_operations event_hist_debug_fops = {
5918 	.open = event_hist_debug_open,
5919 	.read = seq_read,
5920 	.llseek = seq_lseek,
5921 	.release = single_release,
5922 };
5923 #endif
5924 
5925 static void hist_field_print(struct seq_file *m, struct hist_field *hist_field)
5926 {
5927 	const char *field_name = hist_field_name(hist_field, 0);
5928 
5929 	if (hist_field->var.name)
5930 		seq_printf(m, "%s=", hist_field->var.name);
5931 
5932 	if (hist_field->flags & HIST_FIELD_FL_CPU)
5933 		seq_puts(m, "common_cpu");
5934 	else if (hist_field->flags & HIST_FIELD_FL_CONST)
5935 		seq_printf(m, "%llu", hist_field->constant);
5936 	else if (field_name) {
5937 		if (hist_field->flags & HIST_FIELD_FL_VAR_REF ||
5938 		    hist_field->flags & HIST_FIELD_FL_ALIAS)
5939 			seq_putc(m, '$');
5940 		seq_printf(m, "%s", field_name);
5941 	} else if (hist_field->flags & HIST_FIELD_FL_TIMESTAMP)
5942 		seq_puts(m, "common_timestamp");
5943 
5944 	if (hist_field->flags) {
5945 		if (!(hist_field->flags & HIST_FIELD_FL_VAR_REF) &&
5946 		    !(hist_field->flags & HIST_FIELD_FL_EXPR) &&
5947 		    !(hist_field->flags & HIST_FIELD_FL_STACKTRACE)) {
5948 			const char *flags = get_hist_field_flags(hist_field);
5949 
5950 			if (flags)
5951 				seq_printf(m, ".%s", flags);
5952 		}
5953 	}
5954 	if (hist_field->buckets)
5955 		seq_printf(m, "=%ld", hist_field->buckets);
5956 }
5957 
5958 static int event_hist_trigger_print(struct seq_file *m,
5959 				    struct event_trigger_data *data)
5960 {
5961 	struct hist_trigger_data *hist_data = data->private_data;
5962 	struct hist_field *field;
5963 	bool have_var = false;
5964 	bool show_val = false;
5965 	unsigned int i;
5966 
5967 	seq_puts(m, HIST_PREFIX);
5968 
5969 	if (data->name)
5970 		seq_printf(m, "%s:", data->name);
5971 
5972 	seq_puts(m, "keys=");
5973 
5974 	for_each_hist_key_field(i, hist_data) {
5975 		field = hist_data->fields[i];
5976 
5977 		if (i > hist_data->n_vals)
5978 			seq_puts(m, ",");
5979 
5980 		if (field->flags & HIST_FIELD_FL_STACKTRACE) {
5981 			if (field->field)
5982 				seq_printf(m, "%s.stacktrace", field->field->name);
5983 			else
5984 				seq_puts(m, "common_stacktrace");
5985 		} else
5986 			hist_field_print(m, field);
5987 	}
5988 
5989 	seq_puts(m, ":vals=");
5990 
5991 	for_each_hist_val_field(i, hist_data) {
5992 		field = hist_data->fields[i];
5993 		if (field->flags & HIST_FIELD_FL_VAR) {
5994 			have_var = true;
5995 			continue;
5996 		}
5997 
5998 		if (i == HITCOUNT_IDX) {
5999 			if (hist_data->attrs->no_hitcount)
6000 				continue;
6001 			seq_puts(m, "hitcount");
6002 		} else {
6003 			if (show_val)
6004 				seq_puts(m, ",");
6005 			hist_field_print(m, field);
6006 		}
6007 		show_val = true;
6008 	}
6009 
6010 	if (have_var) {
6011 		unsigned int n = 0;
6012 
6013 		seq_puts(m, ":");
6014 
6015 		for_each_hist_val_field(i, hist_data) {
6016 			field = hist_data->fields[i];
6017 
6018 			if (field->flags & HIST_FIELD_FL_VAR) {
6019 				if (n++)
6020 					seq_puts(m, ",");
6021 				hist_field_print(m, field);
6022 			}
6023 		}
6024 	}
6025 
6026 	seq_puts(m, ":sort=");
6027 
6028 	for (i = 0; i < hist_data->n_sort_keys; i++) {
6029 		struct tracing_map_sort_key *sort_key;
6030 		unsigned int idx, first_key_idx;
6031 
6032 		/* skip VAR vals */
6033 		first_key_idx = hist_data->n_vals - hist_data->n_vars;
6034 
6035 		sort_key = &hist_data->sort_keys[i];
6036 		idx = sort_key->field_idx;
6037 
6038 		if (WARN_ON(idx >= HIST_FIELDS_MAX))
6039 			return -EINVAL;
6040 
6041 		if (i > 0)
6042 			seq_puts(m, ",");
6043 
6044 		if (idx == HITCOUNT_IDX)
6045 			seq_puts(m, "hitcount");
6046 		else {
6047 			if (idx >= first_key_idx)
6048 				idx += hist_data->n_vars;
6049 			hist_field_print(m, hist_data->fields[idx]);
6050 		}
6051 
6052 		if (sort_key->descending)
6053 			seq_puts(m, ".descending");
6054 	}
6055 	seq_printf(m, ":size=%u", (1 << hist_data->map->map_bits));
6056 	if (hist_data->enable_timestamps)
6057 		seq_printf(m, ":clock=%s", hist_data->attrs->clock);
6058 	if (hist_data->attrs->no_hitcount)
6059 		seq_puts(m, ":nohitcount");
6060 
6061 	print_actions_spec(m, hist_data);
6062 
6063 	if (data->filter_str)
6064 		seq_printf(m, " if %s", data->filter_str);
6065 
6066 	if (data->paused)
6067 		seq_puts(m, " [paused]");
6068 	else
6069 		seq_puts(m, " [active]");
6070 
6071 	seq_putc(m, '\n');
6072 
6073 	return 0;
6074 }
6075 
6076 static int event_hist_trigger_init(struct event_trigger_data *data)
6077 {
6078 	struct hist_trigger_data *hist_data = data->private_data;
6079 
6080 	if (!data->ref && hist_data->attrs->name)
6081 		save_named_trigger(hist_data->attrs->name, data);
6082 
6083 	data->ref++;
6084 
6085 	return 0;
6086 }
6087 
6088 static void unregister_field_var_hists(struct hist_trigger_data *hist_data)
6089 {
6090 	struct trace_event_file *file;
6091 	unsigned int i;
6092 	char *cmd;
6093 	int ret;
6094 
6095 	for (i = 0; i < hist_data->n_field_var_hists; i++) {
6096 		file = hist_data->field_var_hists[i]->hist_data->event_file;
6097 		cmd = hist_data->field_var_hists[i]->cmd;
6098 		ret = event_hist_trigger_parse(&trigger_hist_cmd, file,
6099 					       "!hist", "hist", cmd);
6100 		WARN_ON_ONCE(ret < 0);
6101 	}
6102 }
6103 
6104 static void event_hist_trigger_free(struct event_trigger_data *data)
6105 {
6106 	struct hist_trigger_data *hist_data = data->private_data;
6107 
6108 	if (WARN_ON_ONCE(data->ref <= 0))
6109 		return;
6110 
6111 	data->ref--;
6112 	if (!data->ref) {
6113 		if (data->name)
6114 			del_named_trigger(data);
6115 
6116 		trigger_data_free(data);
6117 
6118 		remove_hist_vars(hist_data);
6119 
6120 		unregister_field_var_hists(hist_data);
6121 
6122 		destroy_hist_data(hist_data);
6123 	}
6124 }
6125 
6126 static struct event_trigger_ops event_hist_trigger_ops = {
6127 	.trigger		= event_hist_trigger,
6128 	.print			= event_hist_trigger_print,
6129 	.init			= event_hist_trigger_init,
6130 	.free			= event_hist_trigger_free,
6131 };
6132 
6133 static int event_hist_trigger_named_init(struct event_trigger_data *data)
6134 {
6135 	data->ref++;
6136 
6137 	save_named_trigger(data->named_data->name, data);
6138 
6139 	event_hist_trigger_init(data->named_data);
6140 
6141 	return 0;
6142 }
6143 
6144 static void event_hist_trigger_named_free(struct event_trigger_data *data)
6145 {
6146 	if (WARN_ON_ONCE(data->ref <= 0))
6147 		return;
6148 
6149 	event_hist_trigger_free(data->named_data);
6150 
6151 	data->ref--;
6152 	if (!data->ref) {
6153 		del_named_trigger(data);
6154 		trigger_data_free(data);
6155 	}
6156 }
6157 
6158 static struct event_trigger_ops event_hist_trigger_named_ops = {
6159 	.trigger		= event_hist_trigger,
6160 	.print			= event_hist_trigger_print,
6161 	.init			= event_hist_trigger_named_init,
6162 	.free			= event_hist_trigger_named_free,
6163 };
6164 
6165 static struct event_trigger_ops *event_hist_get_trigger_ops(char *cmd,
6166 							    char *param)
6167 {
6168 	return &event_hist_trigger_ops;
6169 }
6170 
6171 static void hist_clear(struct event_trigger_data *data)
6172 {
6173 	struct hist_trigger_data *hist_data = data->private_data;
6174 
6175 	if (data->name)
6176 		pause_named_trigger(data);
6177 
6178 	tracepoint_synchronize_unregister();
6179 
6180 	tracing_map_clear(hist_data->map);
6181 
6182 	if (data->name)
6183 		unpause_named_trigger(data);
6184 }
6185 
6186 static bool compatible_field(struct ftrace_event_field *field,
6187 			     struct ftrace_event_field *test_field)
6188 {
6189 	if (field == test_field)
6190 		return true;
6191 	if (field == NULL || test_field == NULL)
6192 		return false;
6193 	if (strcmp(field->name, test_field->name) != 0)
6194 		return false;
6195 	if (strcmp(field->type, test_field->type) != 0)
6196 		return false;
6197 	if (field->size != test_field->size)
6198 		return false;
6199 	if (field->is_signed != test_field->is_signed)
6200 		return false;
6201 
6202 	return true;
6203 }
6204 
6205 static bool hist_trigger_match(struct event_trigger_data *data,
6206 			       struct event_trigger_data *data_test,
6207 			       struct event_trigger_data *named_data,
6208 			       bool ignore_filter)
6209 {
6210 	struct tracing_map_sort_key *sort_key, *sort_key_test;
6211 	struct hist_trigger_data *hist_data, *hist_data_test;
6212 	struct hist_field *key_field, *key_field_test;
6213 	unsigned int i;
6214 
6215 	if (named_data && (named_data != data_test) &&
6216 	    (named_data != data_test->named_data))
6217 		return false;
6218 
6219 	if (!named_data && is_named_trigger(data_test))
6220 		return false;
6221 
6222 	hist_data = data->private_data;
6223 	hist_data_test = data_test->private_data;
6224 
6225 	if (hist_data->n_vals != hist_data_test->n_vals ||
6226 	    hist_data->n_fields != hist_data_test->n_fields ||
6227 	    hist_data->n_sort_keys != hist_data_test->n_sort_keys)
6228 		return false;
6229 
6230 	if (!ignore_filter) {
6231 		if ((data->filter_str && !data_test->filter_str) ||
6232 		   (!data->filter_str && data_test->filter_str))
6233 			return false;
6234 	}
6235 
6236 	for_each_hist_field(i, hist_data) {
6237 		key_field = hist_data->fields[i];
6238 		key_field_test = hist_data_test->fields[i];
6239 
6240 		if (key_field->flags != key_field_test->flags)
6241 			return false;
6242 		if (!compatible_field(key_field->field, key_field_test->field))
6243 			return false;
6244 		if (key_field->offset != key_field_test->offset)
6245 			return false;
6246 		if (key_field->size != key_field_test->size)
6247 			return false;
6248 		if (key_field->is_signed != key_field_test->is_signed)
6249 			return false;
6250 		if (!!key_field->var.name != !!key_field_test->var.name)
6251 			return false;
6252 		if (key_field->var.name &&
6253 		    strcmp(key_field->var.name, key_field_test->var.name) != 0)
6254 			return false;
6255 	}
6256 
6257 	for (i = 0; i < hist_data->n_sort_keys; i++) {
6258 		sort_key = &hist_data->sort_keys[i];
6259 		sort_key_test = &hist_data_test->sort_keys[i];
6260 
6261 		if (sort_key->field_idx != sort_key_test->field_idx ||
6262 		    sort_key->descending != sort_key_test->descending)
6263 			return false;
6264 	}
6265 
6266 	if (!ignore_filter && data->filter_str &&
6267 	    (strcmp(data->filter_str, data_test->filter_str) != 0))
6268 		return false;
6269 
6270 	if (!actions_match(hist_data, hist_data_test))
6271 		return false;
6272 
6273 	return true;
6274 }
6275 
6276 static bool existing_hist_update_only(char *glob,
6277 				      struct event_trigger_data *data,
6278 				      struct trace_event_file *file)
6279 {
6280 	struct hist_trigger_data *hist_data = data->private_data;
6281 	struct event_trigger_data *test, *named_data = NULL;
6282 	bool updated = false;
6283 
6284 	if (!hist_data->attrs->pause && !hist_data->attrs->cont &&
6285 	    !hist_data->attrs->clear)
6286 		goto out;
6287 
6288 	if (hist_data->attrs->name) {
6289 		named_data = find_named_trigger(hist_data->attrs->name);
6290 		if (named_data) {
6291 			if (!hist_trigger_match(data, named_data, named_data,
6292 						true))
6293 				goto out;
6294 		}
6295 	}
6296 
6297 	if (hist_data->attrs->name && !named_data)
6298 		goto out;
6299 
6300 	list_for_each_entry(test, &file->triggers, list) {
6301 		if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
6302 			if (!hist_trigger_match(data, test, named_data, false))
6303 				continue;
6304 			if (hist_data->attrs->pause)
6305 				test->paused = true;
6306 			else if (hist_data->attrs->cont)
6307 				test->paused = false;
6308 			else if (hist_data->attrs->clear)
6309 				hist_clear(test);
6310 			updated = true;
6311 			goto out;
6312 		}
6313 	}
6314  out:
6315 	return updated;
6316 }
6317 
6318 static int hist_register_trigger(char *glob,
6319 				 struct event_trigger_data *data,
6320 				 struct trace_event_file *file)
6321 {
6322 	struct hist_trigger_data *hist_data = data->private_data;
6323 	struct event_trigger_data *test, *named_data = NULL;
6324 	struct trace_array *tr = file->tr;
6325 	int ret = 0;
6326 
6327 	if (hist_data->attrs->name) {
6328 		named_data = find_named_trigger(hist_data->attrs->name);
6329 		if (named_data) {
6330 			if (!hist_trigger_match(data, named_data, named_data,
6331 						true)) {
6332 				hist_err(tr, HIST_ERR_NAMED_MISMATCH, errpos(hist_data->attrs->name));
6333 				ret = -EINVAL;
6334 				goto out;
6335 			}
6336 		}
6337 	}
6338 
6339 	if (hist_data->attrs->name && !named_data)
6340 		goto new;
6341 
6342 	lockdep_assert_held(&event_mutex);
6343 
6344 	list_for_each_entry(test, &file->triggers, list) {
6345 		if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
6346 			if (hist_trigger_match(data, test, named_data, false)) {
6347 				hist_err(tr, HIST_ERR_TRIGGER_EEXIST, 0);
6348 				ret = -EEXIST;
6349 				goto out;
6350 			}
6351 		}
6352 	}
6353  new:
6354 	if (hist_data->attrs->cont || hist_data->attrs->clear) {
6355 		hist_err(tr, HIST_ERR_TRIGGER_ENOENT_CLEAR, 0);
6356 		ret = -ENOENT;
6357 		goto out;
6358 	}
6359 
6360 	if (hist_data->attrs->pause)
6361 		data->paused = true;
6362 
6363 	if (named_data) {
6364 		data->private_data = named_data->private_data;
6365 		set_named_trigger_data(data, named_data);
6366 		data->ops = &event_hist_trigger_named_ops;
6367 	}
6368 
6369 	if (data->ops->init) {
6370 		ret = data->ops->init(data);
6371 		if (ret < 0)
6372 			goto out;
6373 	}
6374 
6375 	if (hist_data->enable_timestamps) {
6376 		char *clock = hist_data->attrs->clock;
6377 
6378 		ret = tracing_set_clock(file->tr, hist_data->attrs->clock);
6379 		if (ret) {
6380 			hist_err(tr, HIST_ERR_SET_CLOCK_FAIL, errpos(clock));
6381 			goto out;
6382 		}
6383 
6384 		tracing_set_filter_buffering(file->tr, true);
6385 	}
6386 
6387 	if (named_data)
6388 		destroy_hist_data(hist_data);
6389  out:
6390 	return ret;
6391 }
6392 
6393 static int hist_trigger_enable(struct event_trigger_data *data,
6394 			       struct trace_event_file *file)
6395 {
6396 	int ret = 0;
6397 
6398 	list_add_tail_rcu(&data->list, &file->triggers);
6399 
6400 	update_cond_flag(file);
6401 
6402 	if (trace_event_trigger_enable_disable(file, 1) < 0) {
6403 		list_del_rcu(&data->list);
6404 		update_cond_flag(file);
6405 		ret--;
6406 	}
6407 
6408 	return ret;
6409 }
6410 
6411 static bool have_hist_trigger_match(struct event_trigger_data *data,
6412 				    struct trace_event_file *file)
6413 {
6414 	struct hist_trigger_data *hist_data = data->private_data;
6415 	struct event_trigger_data *test, *named_data = NULL;
6416 	bool match = false;
6417 
6418 	lockdep_assert_held(&event_mutex);
6419 
6420 	if (hist_data->attrs->name)
6421 		named_data = find_named_trigger(hist_data->attrs->name);
6422 
6423 	list_for_each_entry(test, &file->triggers, list) {
6424 		if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
6425 			if (hist_trigger_match(data, test, named_data, false)) {
6426 				match = true;
6427 				break;
6428 			}
6429 		}
6430 	}
6431 
6432 	return match;
6433 }
6434 
6435 static bool hist_trigger_check_refs(struct event_trigger_data *data,
6436 				    struct trace_event_file *file)
6437 {
6438 	struct hist_trigger_data *hist_data = data->private_data;
6439 	struct event_trigger_data *test, *named_data = NULL;
6440 
6441 	lockdep_assert_held(&event_mutex);
6442 
6443 	if (hist_data->attrs->name)
6444 		named_data = find_named_trigger(hist_data->attrs->name);
6445 
6446 	list_for_each_entry(test, &file->triggers, list) {
6447 		if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
6448 			if (!hist_trigger_match(data, test, named_data, false))
6449 				continue;
6450 			hist_data = test->private_data;
6451 			if (check_var_refs(hist_data))
6452 				return true;
6453 			break;
6454 		}
6455 	}
6456 
6457 	return false;
6458 }
6459 
6460 static void hist_unregister_trigger(char *glob,
6461 				    struct event_trigger_data *data,
6462 				    struct trace_event_file *file)
6463 {
6464 	struct event_trigger_data *test = NULL, *iter, *named_data = NULL;
6465 	struct hist_trigger_data *hist_data = data->private_data;
6466 
6467 	lockdep_assert_held(&event_mutex);
6468 
6469 	if (hist_data->attrs->name)
6470 		named_data = find_named_trigger(hist_data->attrs->name);
6471 
6472 	list_for_each_entry(iter, &file->triggers, list) {
6473 		if (iter->cmd_ops->trigger_type == ETT_EVENT_HIST) {
6474 			if (!hist_trigger_match(data, iter, named_data, false))
6475 				continue;
6476 			test = iter;
6477 			list_del_rcu(&test->list);
6478 			trace_event_trigger_enable_disable(file, 0);
6479 			update_cond_flag(file);
6480 			break;
6481 		}
6482 	}
6483 
6484 	if (test && test->ops->free)
6485 		test->ops->free(test);
6486 
6487 	if (hist_data->enable_timestamps) {
6488 		if (!hist_data->remove || test)
6489 			tracing_set_filter_buffering(file->tr, false);
6490 	}
6491 }
6492 
6493 static bool hist_file_check_refs(struct trace_event_file *file)
6494 {
6495 	struct hist_trigger_data *hist_data;
6496 	struct event_trigger_data *test;
6497 
6498 	lockdep_assert_held(&event_mutex);
6499 
6500 	list_for_each_entry(test, &file->triggers, list) {
6501 		if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
6502 			hist_data = test->private_data;
6503 			if (check_var_refs(hist_data))
6504 				return true;
6505 		}
6506 	}
6507 
6508 	return false;
6509 }
6510 
6511 static void hist_unreg_all(struct trace_event_file *file)
6512 {
6513 	struct event_trigger_data *test, *n;
6514 	struct hist_trigger_data *hist_data;
6515 	struct synth_event *se;
6516 	const char *se_name;
6517 
6518 	lockdep_assert_held(&event_mutex);
6519 
6520 	if (hist_file_check_refs(file))
6521 		return;
6522 
6523 	list_for_each_entry_safe(test, n, &file->triggers, list) {
6524 		if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
6525 			hist_data = test->private_data;
6526 			list_del_rcu(&test->list);
6527 			trace_event_trigger_enable_disable(file, 0);
6528 
6529 			se_name = trace_event_name(file->event_call);
6530 			se = find_synth_event(se_name);
6531 			if (se)
6532 				se->ref--;
6533 
6534 			update_cond_flag(file);
6535 			if (hist_data->enable_timestamps)
6536 				tracing_set_filter_buffering(file->tr, false);
6537 			if (test->ops->free)
6538 				test->ops->free(test);
6539 		}
6540 	}
6541 }
6542 
6543 static int event_hist_trigger_parse(struct event_command *cmd_ops,
6544 				    struct trace_event_file *file,
6545 				    char *glob, char *cmd,
6546 				    char *param_and_filter)
6547 {
6548 	unsigned int hist_trigger_bits = TRACING_MAP_BITS_DEFAULT;
6549 	struct event_trigger_data *trigger_data;
6550 	struct hist_trigger_attrs *attrs;
6551 	struct hist_trigger_data *hist_data;
6552 	char *param, *filter, *p, *start;
6553 	struct synth_event *se;
6554 	const char *se_name;
6555 	bool remove;
6556 	int ret = 0;
6557 
6558 	lockdep_assert_held(&event_mutex);
6559 
6560 	if (WARN_ON(!glob))
6561 		return -EINVAL;
6562 
6563 	if (glob[0]) {
6564 		hist_err_clear();
6565 		last_cmd_set(file, param_and_filter);
6566 	}
6567 
6568 	remove = event_trigger_check_remove(glob);
6569 
6570 	if (event_trigger_empty_param(param_and_filter))
6571 		return -EINVAL;
6572 
6573 	/*
6574 	 * separate the trigger from the filter (k:v [if filter])
6575 	 * allowing for whitespace in the trigger
6576 	 */
6577 	p = param = param_and_filter;
6578 	do {
6579 		p = strstr(p, "if");
6580 		if (!p)
6581 			break;
6582 		if (p == param_and_filter)
6583 			return -EINVAL;
6584 		if (*(p - 1) != ' ' && *(p - 1) != '\t') {
6585 			p++;
6586 			continue;
6587 		}
6588 		if (p >= param_and_filter + strlen(param_and_filter) - (sizeof("if") - 1) - 1)
6589 			return -EINVAL;
6590 		if (*(p + sizeof("if") - 1) != ' ' && *(p + sizeof("if") - 1) != '\t') {
6591 			p++;
6592 			continue;
6593 		}
6594 		break;
6595 	} while (1);
6596 
6597 	if (!p)
6598 		filter = NULL;
6599 	else {
6600 		*(p - 1) = '\0';
6601 		filter = strstrip(p);
6602 		param = strstrip(param);
6603 	}
6604 
6605 	/*
6606 	 * To simplify arithmetic expression parsing, replace occurrences of
6607 	 * '.sym-offset' modifier with '.symXoffset'
6608 	 */
6609 	start = strstr(param, ".sym-offset");
6610 	while (start) {
6611 		*(start + 4) = 'X';
6612 		start = strstr(start + 11, ".sym-offset");
6613 	}
6614 
6615 	attrs = parse_hist_trigger_attrs(file->tr, param);
6616 	if (IS_ERR(attrs))
6617 		return PTR_ERR(attrs);
6618 
6619 	if (attrs->map_bits)
6620 		hist_trigger_bits = attrs->map_bits;
6621 
6622 	hist_data = create_hist_data(hist_trigger_bits, attrs, file, remove);
6623 	if (IS_ERR(hist_data)) {
6624 		destroy_hist_trigger_attrs(attrs);
6625 		return PTR_ERR(hist_data);
6626 	}
6627 
6628 	trigger_data = event_trigger_alloc(cmd_ops, cmd, param, hist_data);
6629 	if (!trigger_data) {
6630 		ret = -ENOMEM;
6631 		goto out_free;
6632 	}
6633 
6634 	ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);
6635 	if (ret < 0)
6636 		goto out_free;
6637 
6638 	if (remove) {
6639 		if (!have_hist_trigger_match(trigger_data, file))
6640 			goto out_free;
6641 
6642 		if (hist_trigger_check_refs(trigger_data, file)) {
6643 			ret = -EBUSY;
6644 			goto out_free;
6645 		}
6646 
6647 		event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
6648 		se_name = trace_event_name(file->event_call);
6649 		se = find_synth_event(se_name);
6650 		if (se)
6651 			se->ref--;
6652 		ret = 0;
6653 		goto out_free;
6654 	}
6655 
6656 	if (existing_hist_update_only(glob, trigger_data, file))
6657 		goto out_free;
6658 
6659 	ret = event_trigger_register(cmd_ops, file, glob, trigger_data);
6660 	if (ret < 0)
6661 		goto out_free;
6662 
6663 	if (get_named_trigger_data(trigger_data))
6664 		goto enable;
6665 
6666 	ret = create_actions(hist_data);
6667 	if (ret)
6668 		goto out_unreg;
6669 
6670 	if (has_hist_vars(hist_data) || hist_data->n_var_refs) {
6671 		ret = save_hist_vars(hist_data);
6672 		if (ret)
6673 			goto out_unreg;
6674 	}
6675 
6676 	ret = tracing_map_init(hist_data->map);
6677 	if (ret)
6678 		goto out_unreg;
6679 enable:
6680 	ret = hist_trigger_enable(trigger_data, file);
6681 	if (ret)
6682 		goto out_unreg;
6683 
6684 	se_name = trace_event_name(file->event_call);
6685 	se = find_synth_event(se_name);
6686 	if (se)
6687 		se->ref++;
6688  out:
6689 	if (ret == 0 && glob[0])
6690 		hist_err_clear();
6691 
6692 	return ret;
6693  out_unreg:
6694 	event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
6695  out_free:
6696 	event_trigger_reset_filter(cmd_ops, trigger_data);
6697 
6698 	remove_hist_vars(hist_data);
6699 
6700 	kfree(trigger_data);
6701 
6702 	destroy_hist_data(hist_data);
6703 	goto out;
6704 }
6705 
6706 static struct event_command trigger_hist_cmd = {
6707 	.name			= "hist",
6708 	.trigger_type		= ETT_EVENT_HIST,
6709 	.flags			= EVENT_CMD_FL_NEEDS_REC,
6710 	.parse			= event_hist_trigger_parse,
6711 	.reg			= hist_register_trigger,
6712 	.unreg			= hist_unregister_trigger,
6713 	.unreg_all		= hist_unreg_all,
6714 	.get_trigger_ops	= event_hist_get_trigger_ops,
6715 	.set_filter		= set_trigger_filter,
6716 };
6717 
6718 __init int register_trigger_hist_cmd(void)
6719 {
6720 	int ret;
6721 
6722 	ret = register_event_command(&trigger_hist_cmd);
6723 	WARN_ON(ret < 0);
6724 
6725 	return ret;
6726 }
6727 
6728 static void
6729 hist_enable_trigger(struct event_trigger_data *data,
6730 		    struct trace_buffer *buffer,  void *rec,
6731 		    struct ring_buffer_event *event)
6732 {
6733 	struct enable_trigger_data *enable_data = data->private_data;
6734 	struct event_trigger_data *test;
6735 
6736 	list_for_each_entry_rcu(test, &enable_data->file->triggers, list,
6737 				lockdep_is_held(&event_mutex)) {
6738 		if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
6739 			if (enable_data->enable)
6740 				test->paused = false;
6741 			else
6742 				test->paused = true;
6743 		}
6744 	}
6745 }
6746 
6747 static void
6748 hist_enable_count_trigger(struct event_trigger_data *data,
6749 			  struct trace_buffer *buffer,  void *rec,
6750 			  struct ring_buffer_event *event)
6751 {
6752 	if (!data->count)
6753 		return;
6754 
6755 	if (data->count != -1)
6756 		(data->count)--;
6757 
6758 	hist_enable_trigger(data, buffer, rec, event);
6759 }
6760 
6761 static struct event_trigger_ops hist_enable_trigger_ops = {
6762 	.trigger		= hist_enable_trigger,
6763 	.print			= event_enable_trigger_print,
6764 	.init			= event_trigger_init,
6765 	.free			= event_enable_trigger_free,
6766 };
6767 
6768 static struct event_trigger_ops hist_enable_count_trigger_ops = {
6769 	.trigger		= hist_enable_count_trigger,
6770 	.print			= event_enable_trigger_print,
6771 	.init			= event_trigger_init,
6772 	.free			= event_enable_trigger_free,
6773 };
6774 
6775 static struct event_trigger_ops hist_disable_trigger_ops = {
6776 	.trigger		= hist_enable_trigger,
6777 	.print			= event_enable_trigger_print,
6778 	.init			= event_trigger_init,
6779 	.free			= event_enable_trigger_free,
6780 };
6781 
6782 static struct event_trigger_ops hist_disable_count_trigger_ops = {
6783 	.trigger		= hist_enable_count_trigger,
6784 	.print			= event_enable_trigger_print,
6785 	.init			= event_trigger_init,
6786 	.free			= event_enable_trigger_free,
6787 };
6788 
6789 static struct event_trigger_ops *
6790 hist_enable_get_trigger_ops(char *cmd, char *param)
6791 {
6792 	struct event_trigger_ops *ops;
6793 	bool enable;
6794 
6795 	enable = (strcmp(cmd, ENABLE_HIST_STR) == 0);
6796 
6797 	if (enable)
6798 		ops = param ? &hist_enable_count_trigger_ops :
6799 			&hist_enable_trigger_ops;
6800 	else
6801 		ops = param ? &hist_disable_count_trigger_ops :
6802 			&hist_disable_trigger_ops;
6803 
6804 	return ops;
6805 }
6806 
6807 static void hist_enable_unreg_all(struct trace_event_file *file)
6808 {
6809 	struct event_trigger_data *test, *n;
6810 
6811 	list_for_each_entry_safe(test, n, &file->triggers, list) {
6812 		if (test->cmd_ops->trigger_type == ETT_HIST_ENABLE) {
6813 			list_del_rcu(&test->list);
6814 			update_cond_flag(file);
6815 			trace_event_trigger_enable_disable(file, 0);
6816 			if (test->ops->free)
6817 				test->ops->free(test);
6818 		}
6819 	}
6820 }
6821 
6822 static struct event_command trigger_hist_enable_cmd = {
6823 	.name			= ENABLE_HIST_STR,
6824 	.trigger_type		= ETT_HIST_ENABLE,
6825 	.parse			= event_enable_trigger_parse,
6826 	.reg			= event_enable_register_trigger,
6827 	.unreg			= event_enable_unregister_trigger,
6828 	.unreg_all		= hist_enable_unreg_all,
6829 	.get_trigger_ops	= hist_enable_get_trigger_ops,
6830 	.set_filter		= set_trigger_filter,
6831 };
6832 
6833 static struct event_command trigger_hist_disable_cmd = {
6834 	.name			= DISABLE_HIST_STR,
6835 	.trigger_type		= ETT_HIST_ENABLE,
6836 	.parse			= event_enable_trigger_parse,
6837 	.reg			= event_enable_register_trigger,
6838 	.unreg			= event_enable_unregister_trigger,
6839 	.unreg_all		= hist_enable_unreg_all,
6840 	.get_trigger_ops	= hist_enable_get_trigger_ops,
6841 	.set_filter		= set_trigger_filter,
6842 };
6843 
6844 static __init void unregister_trigger_hist_enable_disable_cmds(void)
6845 {
6846 	unregister_event_command(&trigger_hist_enable_cmd);
6847 	unregister_event_command(&trigger_hist_disable_cmd);
6848 }
6849 
6850 __init int register_trigger_hist_enable_disable_cmds(void)
6851 {
6852 	int ret;
6853 
6854 	ret = register_event_command(&trigger_hist_enable_cmd);
6855 	if (WARN_ON(ret < 0))
6856 		return ret;
6857 	ret = register_event_command(&trigger_hist_disable_cmd);
6858 	if (WARN_ON(ret < 0))
6859 		unregister_trigger_hist_enable_disable_cmds();
6860 
6861 	return ret;
6862 }
6863