1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * trace_events_synth - synthetic trace events
4  *
5  * Copyright (C) 2015, 2020 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 #include "trace_probe.h"
21 #include "trace_probe_kernel.h"
22 
23 #include "trace_synth.h"
24 
25 #undef ERRORS
26 #define ERRORS	\
27 	C(BAD_NAME,		"Illegal name"),		\
28 	C(INVALID_CMD,		"Command must be of the form: <name> field[;field] ..."),\
29 	C(INVALID_DYN_CMD,	"Command must be of the form: s or -:[synthetic/]<name> field[;field] ..."),\
30 	C(EVENT_EXISTS,		"Event already exists"),	\
31 	C(TOO_MANY_FIELDS,	"Too many fields"),		\
32 	C(INCOMPLETE_TYPE,	"Incomplete type"),		\
33 	C(INVALID_TYPE,		"Invalid type"),		\
34 	C(INVALID_FIELD,        "Invalid field"),		\
35 	C(INVALID_ARRAY_SPEC,	"Invalid array specification"),
36 
37 #undef C
38 #define C(a, b)		SYNTH_ERR_##a
39 
40 enum { ERRORS };
41 
42 #undef C
43 #define C(a, b)		b
44 
45 static const char *err_text[] = { ERRORS };
46 
47 static DEFINE_MUTEX(lastcmd_mutex);
48 static char *last_cmd;
49 
50 static int errpos(const char *str)
51 {
52 	int ret = 0;
53 
54 	mutex_lock(&lastcmd_mutex);
55 	if (!str || !last_cmd)
56 		goto out;
57 
58 	ret = err_pos(last_cmd, str);
59  out:
60 	mutex_unlock(&lastcmd_mutex);
61 	return ret;
62 }
63 
64 static void last_cmd_set(const char *str)
65 {
66 	if (!str)
67 		return;
68 
69 	mutex_lock(&lastcmd_mutex);
70 	kfree(last_cmd);
71 	last_cmd = kstrdup(str, GFP_KERNEL);
72 	mutex_unlock(&lastcmd_mutex);
73 }
74 
75 static void synth_err(u8 err_type, u16 err_pos)
76 {
77 	mutex_lock(&lastcmd_mutex);
78 	if (!last_cmd)
79 		goto out;
80 
81 	tracing_log_err(NULL, "synthetic_events", last_cmd, err_text,
82 			err_type, err_pos);
83  out:
84 	mutex_unlock(&lastcmd_mutex);
85 }
86 
87 static int create_synth_event(const char *raw_command);
88 static int synth_event_show(struct seq_file *m, struct dyn_event *ev);
89 static int synth_event_release(struct dyn_event *ev);
90 static bool synth_event_is_busy(struct dyn_event *ev);
91 static bool synth_event_match(const char *system, const char *event,
92 			int argc, const char **argv, struct dyn_event *ev);
93 
94 static struct dyn_event_operations synth_event_ops = {
95 	.create = create_synth_event,
96 	.show = synth_event_show,
97 	.is_busy = synth_event_is_busy,
98 	.free = synth_event_release,
99 	.match = synth_event_match,
100 };
101 
102 static bool is_synth_event(struct dyn_event *ev)
103 {
104 	return ev->ops == &synth_event_ops;
105 }
106 
107 static struct synth_event *to_synth_event(struct dyn_event *ev)
108 {
109 	return container_of(ev, struct synth_event, devent);
110 }
111 
112 static bool synth_event_is_busy(struct dyn_event *ev)
113 {
114 	struct synth_event *event = to_synth_event(ev);
115 
116 	return event->ref != 0;
117 }
118 
119 static bool synth_event_match(const char *system, const char *event,
120 			int argc, const char **argv, struct dyn_event *ev)
121 {
122 	struct synth_event *sev = to_synth_event(ev);
123 
124 	return strcmp(sev->name, event) == 0 &&
125 		(!system || strcmp(system, SYNTH_SYSTEM) == 0);
126 }
127 
128 struct synth_trace_event {
129 	struct trace_entry	ent;
130 	union trace_synth_field	fields[];
131 };
132 
133 static int synth_event_define_fields(struct trace_event_call *call)
134 {
135 	struct synth_trace_event trace;
136 	int offset = offsetof(typeof(trace), fields);
137 	struct synth_event *event = call->data;
138 	unsigned int i, size, n_u64;
139 	char *name, *type;
140 	bool is_signed;
141 	int ret = 0;
142 
143 	for (i = 0, n_u64 = 0; i < event->n_fields; i++) {
144 		size = event->fields[i]->size;
145 		is_signed = event->fields[i]->is_signed;
146 		type = event->fields[i]->type;
147 		name = event->fields[i]->name;
148 		ret = trace_define_field(call, type, name, offset, size,
149 					 is_signed, FILTER_OTHER);
150 		if (ret)
151 			break;
152 
153 		event->fields[i]->offset = n_u64;
154 
155 		if (event->fields[i]->is_string && !event->fields[i]->is_dynamic) {
156 			offset += STR_VAR_LEN_MAX;
157 			n_u64 += STR_VAR_LEN_MAX / sizeof(u64);
158 		} else {
159 			offset += sizeof(u64);
160 			n_u64++;
161 		}
162 	}
163 
164 	event->n_u64 = n_u64;
165 
166 	return ret;
167 }
168 
169 static bool synth_field_signed(char *type)
170 {
171 	if (str_has_prefix(type, "u"))
172 		return false;
173 	if (strcmp(type, "gfp_t") == 0)
174 		return false;
175 
176 	return true;
177 }
178 
179 static int synth_field_is_string(char *type)
180 {
181 	if (strstr(type, "char[") != NULL)
182 		return true;
183 
184 	return false;
185 }
186 
187 static int synth_field_is_stack(char *type)
188 {
189 	if (strstr(type, "long[") != NULL)
190 		return true;
191 
192 	return false;
193 }
194 
195 static int synth_field_string_size(char *type)
196 {
197 	char buf[4], *end, *start;
198 	unsigned int len;
199 	int size, err;
200 
201 	start = strstr(type, "char[");
202 	if (start == NULL)
203 		return -EINVAL;
204 	start += sizeof("char[") - 1;
205 
206 	end = strchr(type, ']');
207 	if (!end || end < start || type + strlen(type) > end + 1)
208 		return -EINVAL;
209 
210 	len = end - start;
211 	if (len > 3)
212 		return -EINVAL;
213 
214 	if (len == 0)
215 		return 0; /* variable-length string */
216 
217 	strncpy(buf, start, len);
218 	buf[len] = '\0';
219 
220 	err = kstrtouint(buf, 0, &size);
221 	if (err)
222 		return err;
223 
224 	if (size > STR_VAR_LEN_MAX)
225 		return -EINVAL;
226 
227 	return size;
228 }
229 
230 static int synth_field_size(char *type)
231 {
232 	int size = 0;
233 
234 	if (strcmp(type, "s64") == 0)
235 		size = sizeof(s64);
236 	else if (strcmp(type, "u64") == 0)
237 		size = sizeof(u64);
238 	else if (strcmp(type, "s32") == 0)
239 		size = sizeof(s32);
240 	else if (strcmp(type, "u32") == 0)
241 		size = sizeof(u32);
242 	else if (strcmp(type, "s16") == 0)
243 		size = sizeof(s16);
244 	else if (strcmp(type, "u16") == 0)
245 		size = sizeof(u16);
246 	else if (strcmp(type, "s8") == 0)
247 		size = sizeof(s8);
248 	else if (strcmp(type, "u8") == 0)
249 		size = sizeof(u8);
250 	else if (strcmp(type, "char") == 0)
251 		size = sizeof(char);
252 	else if (strcmp(type, "unsigned char") == 0)
253 		size = sizeof(unsigned char);
254 	else if (strcmp(type, "int") == 0)
255 		size = sizeof(int);
256 	else if (strcmp(type, "unsigned int") == 0)
257 		size = sizeof(unsigned int);
258 	else if (strcmp(type, "long") == 0)
259 		size = sizeof(long);
260 	else if (strcmp(type, "unsigned long") == 0)
261 		size = sizeof(unsigned long);
262 	else if (strcmp(type, "bool") == 0)
263 		size = sizeof(bool);
264 	else if (strcmp(type, "pid_t") == 0)
265 		size = sizeof(pid_t);
266 	else if (strcmp(type, "gfp_t") == 0)
267 		size = sizeof(gfp_t);
268 	else if (synth_field_is_string(type))
269 		size = synth_field_string_size(type);
270 	else if (synth_field_is_stack(type))
271 		size = 0;
272 
273 	return size;
274 }
275 
276 static const char *synth_field_fmt(char *type)
277 {
278 	const char *fmt = "%llu";
279 
280 	if (strcmp(type, "s64") == 0)
281 		fmt = "%lld";
282 	else if (strcmp(type, "u64") == 0)
283 		fmt = "%llu";
284 	else if (strcmp(type, "s32") == 0)
285 		fmt = "%d";
286 	else if (strcmp(type, "u32") == 0)
287 		fmt = "%u";
288 	else if (strcmp(type, "s16") == 0)
289 		fmt = "%d";
290 	else if (strcmp(type, "u16") == 0)
291 		fmt = "%u";
292 	else if (strcmp(type, "s8") == 0)
293 		fmt = "%d";
294 	else if (strcmp(type, "u8") == 0)
295 		fmt = "%u";
296 	else if (strcmp(type, "char") == 0)
297 		fmt = "%d";
298 	else if (strcmp(type, "unsigned char") == 0)
299 		fmt = "%u";
300 	else if (strcmp(type, "int") == 0)
301 		fmt = "%d";
302 	else if (strcmp(type, "unsigned int") == 0)
303 		fmt = "%u";
304 	else if (strcmp(type, "long") == 0)
305 		fmt = "%ld";
306 	else if (strcmp(type, "unsigned long") == 0)
307 		fmt = "%lu";
308 	else if (strcmp(type, "bool") == 0)
309 		fmt = "%d";
310 	else if (strcmp(type, "pid_t") == 0)
311 		fmt = "%d";
312 	else if (strcmp(type, "gfp_t") == 0)
313 		fmt = "%x";
314 	else if (synth_field_is_string(type))
315 		fmt = "%.*s";
316 	else if (synth_field_is_stack(type))
317 		fmt = "%s";
318 
319 	return fmt;
320 }
321 
322 static void print_synth_event_num_val(struct trace_seq *s,
323 				      char *print_fmt, char *name,
324 				      int size, union trace_synth_field *val, char *space)
325 {
326 	switch (size) {
327 	case 1:
328 		trace_seq_printf(s, print_fmt, name, val->as_u8, space);
329 		break;
330 
331 	case 2:
332 		trace_seq_printf(s, print_fmt, name, val->as_u16, space);
333 		break;
334 
335 	case 4:
336 		trace_seq_printf(s, print_fmt, name, val->as_u32, space);
337 		break;
338 
339 	default:
340 		trace_seq_printf(s, print_fmt, name, val->as_u64, space);
341 		break;
342 	}
343 }
344 
345 static enum print_line_t print_synth_event(struct trace_iterator *iter,
346 					   int flags,
347 					   struct trace_event *event)
348 {
349 	struct trace_array *tr = iter->tr;
350 	struct trace_seq *s = &iter->seq;
351 	struct synth_trace_event *entry;
352 	struct synth_event *se;
353 	unsigned int i, j, n_u64;
354 	char print_fmt[32];
355 	const char *fmt;
356 
357 	entry = (struct synth_trace_event *)iter->ent;
358 	se = container_of(event, struct synth_event, call.event);
359 
360 	trace_seq_printf(s, "%s: ", se->name);
361 
362 	for (i = 0, n_u64 = 0; i < se->n_fields; i++) {
363 		if (trace_seq_has_overflowed(s))
364 			goto end;
365 
366 		fmt = synth_field_fmt(se->fields[i]->type);
367 
368 		/* parameter types */
369 		if (tr && tr->trace_flags & TRACE_ITER_VERBOSE)
370 			trace_seq_printf(s, "%s ", fmt);
371 
372 		snprintf(print_fmt, sizeof(print_fmt), "%%s=%s%%s", fmt);
373 
374 		/* parameter values */
375 		if (se->fields[i]->is_string) {
376 			if (se->fields[i]->is_dynamic) {
377 				union trace_synth_field *data = &entry->fields[n_u64];
378 
379 				trace_seq_printf(s, print_fmt, se->fields[i]->name,
380 						 STR_VAR_LEN_MAX,
381 						 (char *)entry + data->as_dynamic.offset,
382 						 i == se->n_fields - 1 ? "" : " ");
383 				n_u64++;
384 			} else {
385 				trace_seq_printf(s, print_fmt, se->fields[i]->name,
386 						 STR_VAR_LEN_MAX,
387 						 (char *)&entry->fields[n_u64].as_u64,
388 						 i == se->n_fields - 1 ? "" : " ");
389 				n_u64 += STR_VAR_LEN_MAX / sizeof(u64);
390 			}
391 		} else if (se->fields[i]->is_stack) {
392 			union trace_synth_field *data = &entry->fields[n_u64];
393 			unsigned long *p = (void *)entry + data->as_dynamic.offset;
394 
395 			trace_seq_printf(s, "%s=STACK:\n", se->fields[i]->name);
396 			for (j = 1; j < data->as_dynamic.len / sizeof(long); j++)
397 				trace_seq_printf(s, "=> %pS\n", (void *)p[j]);
398 			n_u64++;
399 		} else {
400 			struct trace_print_flags __flags[] = {
401 			    __def_gfpflag_names, {-1, NULL} };
402 			char *space = (i == se->n_fields - 1 ? "" : " ");
403 
404 			print_synth_event_num_val(s, print_fmt,
405 						  se->fields[i]->name,
406 						  se->fields[i]->size,
407 						  &entry->fields[n_u64],
408 						  space);
409 
410 			if (strcmp(se->fields[i]->type, "gfp_t") == 0) {
411 				trace_seq_puts(s, " (");
412 				trace_print_flags_seq(s, "|",
413 						      entry->fields[n_u64].as_u64,
414 						      __flags);
415 				trace_seq_putc(s, ')');
416 			}
417 			n_u64++;
418 		}
419 	}
420 end:
421 	trace_seq_putc(s, '\n');
422 
423 	return trace_handle_return(s);
424 }
425 
426 static struct trace_event_functions synth_event_funcs = {
427 	.trace		= print_synth_event
428 };
429 
430 static unsigned int trace_string(struct synth_trace_event *entry,
431 				 struct synth_event *event,
432 				 char *str_val,
433 				 bool is_dynamic,
434 				 unsigned int data_size,
435 				 unsigned int *n_u64)
436 {
437 	unsigned int len = 0;
438 	char *str_field;
439 	int ret;
440 
441 	if (is_dynamic) {
442 		union trace_synth_field *data = &entry->fields[*n_u64];
443 
444 		len = fetch_store_strlen((unsigned long)str_val);
445 		data->as_dynamic.offset = struct_size(entry, fields, event->n_u64) + data_size;
446 		data->as_dynamic.len = len;
447 
448 		ret = fetch_store_string((unsigned long)str_val, &entry->fields[*n_u64], entry);
449 
450 		(*n_u64)++;
451 	} else {
452 		str_field = (char *)&entry->fields[*n_u64].as_u64;
453 
454 #ifdef CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE
455 		if ((unsigned long)str_val < TASK_SIZE)
456 			ret = strncpy_from_user_nofault(str_field, (const void __user *)str_val, STR_VAR_LEN_MAX);
457 		else
458 #endif
459 			ret = strncpy_from_kernel_nofault(str_field, str_val, STR_VAR_LEN_MAX);
460 
461 		if (ret < 0)
462 			strcpy(str_field, FAULT_STRING);
463 
464 		(*n_u64) += STR_VAR_LEN_MAX / sizeof(u64);
465 	}
466 
467 	return len;
468 }
469 
470 static unsigned int trace_stack(struct synth_trace_event *entry,
471 				 struct synth_event *event,
472 				 long *stack,
473 				 unsigned int data_size,
474 				 unsigned int *n_u64)
475 {
476 	union trace_synth_field *data = &entry->fields[*n_u64];
477 	unsigned int len;
478 	u32 data_offset;
479 	void *data_loc;
480 
481 	data_offset = struct_size(entry, fields, event->n_u64);
482 	data_offset += data_size;
483 
484 	for (len = 0; len < HIST_STACKTRACE_DEPTH; len++) {
485 		if (!stack[len])
486 			break;
487 	}
488 
489 	len *= sizeof(long);
490 
491 	/* Find the dynamic section to copy the stack into. */
492 	data_loc = (void *)entry + data_offset;
493 	memcpy(data_loc, stack, len);
494 
495 	/* Fill in the field that holds the offset/len combo */
496 
497 	data->as_dynamic.offset = data_offset;
498 	data->as_dynamic.len = len;
499 
500 	(*n_u64)++;
501 
502 	return len;
503 }
504 
505 static notrace void trace_event_raw_event_synth(void *__data,
506 						u64 *var_ref_vals,
507 						unsigned int *var_ref_idx)
508 {
509 	unsigned int i, n_u64, val_idx, len, data_size = 0;
510 	struct trace_event_file *trace_file = __data;
511 	struct synth_trace_event *entry;
512 	struct trace_event_buffer fbuffer;
513 	struct trace_buffer *buffer;
514 	struct synth_event *event;
515 	int fields_size = 0;
516 
517 	event = trace_file->event_call->data;
518 
519 	if (trace_trigger_soft_disabled(trace_file))
520 		return;
521 
522 	fields_size = event->n_u64 * sizeof(u64);
523 
524 	for (i = 0; i < event->n_dynamic_fields; i++) {
525 		unsigned int field_pos = event->dynamic_fields[i]->field_pos;
526 		char *str_val;
527 
528 		val_idx = var_ref_idx[field_pos];
529 		str_val = (char *)(long)var_ref_vals[val_idx];
530 
531 		if (event->dynamic_fields[i]->is_stack) {
532 			/* reserve one extra element for size */
533 			len = *((unsigned long *)str_val) + 1;
534 			len *= sizeof(unsigned long);
535 		} else {
536 			len = fetch_store_strlen((unsigned long)str_val);
537 		}
538 
539 		fields_size += len;
540 	}
541 
542 	/*
543 	 * Avoid ring buffer recursion detection, as this event
544 	 * is being performed within another event.
545 	 */
546 	buffer = trace_file->tr->array_buffer.buffer;
547 	ring_buffer_nest_start(buffer);
548 
549 	entry = trace_event_buffer_reserve(&fbuffer, trace_file,
550 					   sizeof(*entry) + fields_size);
551 	if (!entry)
552 		goto out;
553 
554 	for (i = 0, n_u64 = 0; i < event->n_fields; i++) {
555 		val_idx = var_ref_idx[i];
556 		if (event->fields[i]->is_string) {
557 			char *str_val = (char *)(long)var_ref_vals[val_idx];
558 
559 			len = trace_string(entry, event, str_val,
560 					   event->fields[i]->is_dynamic,
561 					   data_size, &n_u64);
562 			data_size += len; /* only dynamic string increments */
563 		} else if (event->fields[i]->is_stack) {
564 			long *stack = (long *)(long)var_ref_vals[val_idx];
565 
566 			len = trace_stack(entry, event, stack,
567 					   data_size, &n_u64);
568 			data_size += len;
569 		} else {
570 			struct synth_field *field = event->fields[i];
571 			u64 val = var_ref_vals[val_idx];
572 
573 			switch (field->size) {
574 			case 1:
575 				entry->fields[n_u64].as_u8 = (u8)val;
576 				break;
577 
578 			case 2:
579 				entry->fields[n_u64].as_u16 = (u16)val;
580 				break;
581 
582 			case 4:
583 				entry->fields[n_u64].as_u32 = (u32)val;
584 				break;
585 
586 			default:
587 				entry->fields[n_u64].as_u64 = val;
588 				break;
589 			}
590 			n_u64++;
591 		}
592 	}
593 
594 	trace_event_buffer_commit(&fbuffer);
595 out:
596 	ring_buffer_nest_end(buffer);
597 }
598 
599 static void free_synth_event_print_fmt(struct trace_event_call *call)
600 {
601 	if (call) {
602 		kfree(call->print_fmt);
603 		call->print_fmt = NULL;
604 	}
605 }
606 
607 static int __set_synth_event_print_fmt(struct synth_event *event,
608 				       char *buf, int len)
609 {
610 	const char *fmt;
611 	int pos = 0;
612 	int i;
613 
614 	/* When len=0, we just calculate the needed length */
615 #define LEN_OR_ZERO (len ? len - pos : 0)
616 
617 	pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");
618 	for (i = 0; i < event->n_fields; i++) {
619 		fmt = synth_field_fmt(event->fields[i]->type);
620 		pos += snprintf(buf + pos, LEN_OR_ZERO, "%s=%s%s",
621 				event->fields[i]->name, fmt,
622 				i == event->n_fields - 1 ? "" : ", ");
623 	}
624 	pos += snprintf(buf + pos, LEN_OR_ZERO, "\"");
625 
626 	for (i = 0; i < event->n_fields; i++) {
627 		if (event->fields[i]->is_string &&
628 		    event->fields[i]->is_dynamic)
629 			pos += snprintf(buf + pos, LEN_OR_ZERO,
630 				", __get_str(%s)", event->fields[i]->name);
631 		else if (event->fields[i]->is_stack)
632 			pos += snprintf(buf + pos, LEN_OR_ZERO,
633 				", __get_stacktrace(%s)", event->fields[i]->name);
634 		else
635 			pos += snprintf(buf + pos, LEN_OR_ZERO,
636 					", REC->%s", event->fields[i]->name);
637 	}
638 
639 #undef LEN_OR_ZERO
640 
641 	/* return the length of print_fmt */
642 	return pos;
643 }
644 
645 static int set_synth_event_print_fmt(struct trace_event_call *call)
646 {
647 	struct synth_event *event = call->data;
648 	char *print_fmt;
649 	int len;
650 
651 	/* First: called with 0 length to calculate the needed length */
652 	len = __set_synth_event_print_fmt(event, NULL, 0);
653 
654 	print_fmt = kmalloc(len + 1, GFP_KERNEL);
655 	if (!print_fmt)
656 		return -ENOMEM;
657 
658 	/* Second: actually write the @print_fmt */
659 	__set_synth_event_print_fmt(event, print_fmt, len + 1);
660 	call->print_fmt = print_fmt;
661 
662 	return 0;
663 }
664 
665 static void free_synth_field(struct synth_field *field)
666 {
667 	kfree(field->type);
668 	kfree(field->name);
669 	kfree(field);
670 }
671 
672 static int check_field_version(const char *prefix, const char *field_type,
673 			       const char *field_name)
674 {
675 	/*
676 	 * For backward compatibility, the old synthetic event command
677 	 * format did not require semicolons, and in order to not
678 	 * break user space, that old format must still work. If a new
679 	 * feature is added, then the format that uses the new feature
680 	 * will be required to have semicolons, as nothing that uses
681 	 * the old format would be using the new, yet to be created,
682 	 * feature. When a new feature is added, this will detect it,
683 	 * and return a number greater than 1, and require the format
684 	 * to use semicolons.
685 	 */
686 	return 1;
687 }
688 
689 static struct synth_field *parse_synth_field(int argc, char **argv,
690 					     int *consumed, int *field_version)
691 {
692 	const char *prefix = NULL, *field_type = argv[0], *field_name, *array;
693 	struct synth_field *field;
694 	int len, ret = -ENOMEM;
695 	struct seq_buf s;
696 	ssize_t size;
697 
698 	if (!strcmp(field_type, "unsigned")) {
699 		if (argc < 3) {
700 			synth_err(SYNTH_ERR_INCOMPLETE_TYPE, errpos(field_type));
701 			return ERR_PTR(-EINVAL);
702 		}
703 		prefix = "unsigned ";
704 		field_type = argv[1];
705 		field_name = argv[2];
706 		*consumed += 3;
707 	} else {
708 		field_name = argv[1];
709 		*consumed += 2;
710 	}
711 
712 	if (!field_name) {
713 		synth_err(SYNTH_ERR_INVALID_FIELD, errpos(field_type));
714 		return ERR_PTR(-EINVAL);
715 	}
716 
717 	*field_version = check_field_version(prefix, field_type, field_name);
718 
719 	field = kzalloc(sizeof(*field), GFP_KERNEL);
720 	if (!field)
721 		return ERR_PTR(-ENOMEM);
722 
723 	len = strlen(field_name);
724 	array = strchr(field_name, '[');
725 	if (array)
726 		len -= strlen(array);
727 
728 	field->name = kmemdup_nul(field_name, len, GFP_KERNEL);
729 	if (!field->name)
730 		goto free;
731 
732 	if (!is_good_name(field->name)) {
733 		synth_err(SYNTH_ERR_BAD_NAME, errpos(field_name));
734 		ret = -EINVAL;
735 		goto free;
736 	}
737 
738 	len = strlen(field_type) + 1;
739 
740 	if (array)
741 		len += strlen(array);
742 
743 	if (prefix)
744 		len += strlen(prefix);
745 
746 	field->type = kzalloc(len, GFP_KERNEL);
747 	if (!field->type)
748 		goto free;
749 
750 	seq_buf_init(&s, field->type, len);
751 	if (prefix)
752 		seq_buf_puts(&s, prefix);
753 	seq_buf_puts(&s, field_type);
754 	if (array)
755 		seq_buf_puts(&s, array);
756 	if (WARN_ON_ONCE(!seq_buf_buffer_left(&s)))
757 		goto free;
758 
759 	s.buffer[s.len] = '\0';
760 
761 	size = synth_field_size(field->type);
762 	if (size < 0) {
763 		if (array)
764 			synth_err(SYNTH_ERR_INVALID_ARRAY_SPEC, errpos(field_name));
765 		else
766 			synth_err(SYNTH_ERR_INVALID_TYPE, errpos(field_type));
767 		ret = -EINVAL;
768 		goto free;
769 	} else if (size == 0) {
770 		if (synth_field_is_string(field->type) ||
771 		    synth_field_is_stack(field->type)) {
772 			char *type;
773 
774 			len = sizeof("__data_loc ") + strlen(field->type) + 1;
775 			type = kzalloc(len, GFP_KERNEL);
776 			if (!type)
777 				goto free;
778 
779 			seq_buf_init(&s, type, len);
780 			seq_buf_puts(&s, "__data_loc ");
781 			seq_buf_puts(&s, field->type);
782 
783 			if (WARN_ON_ONCE(!seq_buf_buffer_left(&s)))
784 				goto free;
785 			s.buffer[s.len] = '\0';
786 
787 			kfree(field->type);
788 			field->type = type;
789 
790 			field->is_dynamic = true;
791 			size = sizeof(u64);
792 		} else {
793 			synth_err(SYNTH_ERR_INVALID_TYPE, errpos(field_type));
794 			ret = -EINVAL;
795 			goto free;
796 		}
797 	}
798 	field->size = size;
799 
800 	if (synth_field_is_string(field->type))
801 		field->is_string = true;
802 	else if (synth_field_is_stack(field->type))
803 		field->is_stack = true;
804 
805 	field->is_signed = synth_field_signed(field->type);
806  out:
807 	return field;
808  free:
809 	free_synth_field(field);
810 	field = ERR_PTR(ret);
811 	goto out;
812 }
813 
814 static void free_synth_tracepoint(struct tracepoint *tp)
815 {
816 	if (!tp)
817 		return;
818 
819 	kfree(tp->name);
820 	kfree(tp);
821 }
822 
823 static struct tracepoint *alloc_synth_tracepoint(char *name)
824 {
825 	struct tracepoint *tp;
826 
827 	tp = kzalloc(sizeof(*tp), GFP_KERNEL);
828 	if (!tp)
829 		return ERR_PTR(-ENOMEM);
830 
831 	tp->name = kstrdup(name, GFP_KERNEL);
832 	if (!tp->name) {
833 		kfree(tp);
834 		return ERR_PTR(-ENOMEM);
835 	}
836 
837 	return tp;
838 }
839 
840 struct synth_event *find_synth_event(const char *name)
841 {
842 	struct dyn_event *pos;
843 	struct synth_event *event;
844 
845 	for_each_dyn_event(pos) {
846 		if (!is_synth_event(pos))
847 			continue;
848 		event = to_synth_event(pos);
849 		if (strcmp(event->name, name) == 0)
850 			return event;
851 	}
852 
853 	return NULL;
854 }
855 
856 static struct trace_event_fields synth_event_fields_array[] = {
857 	{ .type = TRACE_FUNCTION_TYPE,
858 	  .define_fields = synth_event_define_fields },
859 	{}
860 };
861 
862 static int register_synth_event(struct synth_event *event)
863 {
864 	struct trace_event_call *call = &event->call;
865 	int ret = 0;
866 
867 	event->call.class = &event->class;
868 	event->class.system = kstrdup(SYNTH_SYSTEM, GFP_KERNEL);
869 	if (!event->class.system) {
870 		ret = -ENOMEM;
871 		goto out;
872 	}
873 
874 	event->tp = alloc_synth_tracepoint(event->name);
875 	if (IS_ERR(event->tp)) {
876 		ret = PTR_ERR(event->tp);
877 		event->tp = NULL;
878 		goto out;
879 	}
880 
881 	INIT_LIST_HEAD(&call->class->fields);
882 	call->event.funcs = &synth_event_funcs;
883 	call->class->fields_array = synth_event_fields_array;
884 
885 	ret = register_trace_event(&call->event);
886 	if (!ret) {
887 		ret = -ENODEV;
888 		goto out;
889 	}
890 	call->flags = TRACE_EVENT_FL_TRACEPOINT;
891 	call->class->reg = trace_event_reg;
892 	call->class->probe = trace_event_raw_event_synth;
893 	call->data = event;
894 	call->tp = event->tp;
895 
896 	ret = trace_add_event_call(call);
897 	if (ret) {
898 		pr_warn("Failed to register synthetic event: %s\n",
899 			trace_event_name(call));
900 		goto err;
901 	}
902 
903 	ret = set_synth_event_print_fmt(call);
904 	/* unregister_trace_event() will be called inside */
905 	if (ret < 0)
906 		trace_remove_event_call(call);
907  out:
908 	return ret;
909  err:
910 	unregister_trace_event(&call->event);
911 	goto out;
912 }
913 
914 static int unregister_synth_event(struct synth_event *event)
915 {
916 	struct trace_event_call *call = &event->call;
917 	int ret;
918 
919 	ret = trace_remove_event_call(call);
920 
921 	return ret;
922 }
923 
924 static void free_synth_event(struct synth_event *event)
925 {
926 	unsigned int i;
927 
928 	if (!event)
929 		return;
930 
931 	for (i = 0; i < event->n_fields; i++)
932 		free_synth_field(event->fields[i]);
933 
934 	kfree(event->fields);
935 	kfree(event->dynamic_fields);
936 	kfree(event->name);
937 	kfree(event->class.system);
938 	free_synth_tracepoint(event->tp);
939 	free_synth_event_print_fmt(&event->call);
940 	kfree(event);
941 }
942 
943 static struct synth_event *alloc_synth_event(const char *name, int n_fields,
944 					     struct synth_field **fields)
945 {
946 	unsigned int i, j, n_dynamic_fields = 0;
947 	struct synth_event *event;
948 
949 	event = kzalloc(sizeof(*event), GFP_KERNEL);
950 	if (!event) {
951 		event = ERR_PTR(-ENOMEM);
952 		goto out;
953 	}
954 
955 	event->name = kstrdup(name, GFP_KERNEL);
956 	if (!event->name) {
957 		kfree(event);
958 		event = ERR_PTR(-ENOMEM);
959 		goto out;
960 	}
961 
962 	event->fields = kcalloc(n_fields, sizeof(*event->fields), GFP_KERNEL);
963 	if (!event->fields) {
964 		free_synth_event(event);
965 		event = ERR_PTR(-ENOMEM);
966 		goto out;
967 	}
968 
969 	for (i = 0; i < n_fields; i++)
970 		if (fields[i]->is_dynamic)
971 			n_dynamic_fields++;
972 
973 	if (n_dynamic_fields) {
974 		event->dynamic_fields = kcalloc(n_dynamic_fields,
975 						sizeof(*event->dynamic_fields),
976 						GFP_KERNEL);
977 		if (!event->dynamic_fields) {
978 			free_synth_event(event);
979 			event = ERR_PTR(-ENOMEM);
980 			goto out;
981 		}
982 	}
983 
984 	dyn_event_init(&event->devent, &synth_event_ops);
985 
986 	for (i = 0, j = 0; i < n_fields; i++) {
987 		fields[i]->field_pos = i;
988 		event->fields[i] = fields[i];
989 
990 		if (fields[i]->is_dynamic)
991 			event->dynamic_fields[j++] = fields[i];
992 	}
993 	event->n_dynamic_fields = j;
994 	event->n_fields = n_fields;
995  out:
996 	return event;
997 }
998 
999 static int synth_event_check_arg_fn(void *data)
1000 {
1001 	struct dynevent_arg_pair *arg_pair = data;
1002 	int size;
1003 
1004 	size = synth_field_size((char *)arg_pair->lhs);
1005 	if (size == 0) {
1006 		if (strstr((char *)arg_pair->lhs, "["))
1007 			return 0;
1008 	}
1009 
1010 	return size ? 0 : -EINVAL;
1011 }
1012 
1013 /**
1014  * synth_event_add_field - Add a new field to a synthetic event cmd
1015  * @cmd: A pointer to the dynevent_cmd struct representing the new event
1016  * @type: The type of the new field to add
1017  * @name: The name of the new field to add
1018  *
1019  * Add a new field to a synthetic event cmd object.  Field ordering is in
1020  * the same order the fields are added.
1021  *
1022  * See synth_field_size() for available types. If field_name contains
1023  * [n] the field is considered to be an array.
1024  *
1025  * Return: 0 if successful, error otherwise.
1026  */
1027 int synth_event_add_field(struct dynevent_cmd *cmd, const char *type,
1028 			  const char *name)
1029 {
1030 	struct dynevent_arg_pair arg_pair;
1031 	int ret;
1032 
1033 	if (cmd->type != DYNEVENT_TYPE_SYNTH)
1034 		return -EINVAL;
1035 
1036 	if (!type || !name)
1037 		return -EINVAL;
1038 
1039 	dynevent_arg_pair_init(&arg_pair, 0, ';');
1040 
1041 	arg_pair.lhs = type;
1042 	arg_pair.rhs = name;
1043 
1044 	ret = dynevent_arg_pair_add(cmd, &arg_pair, synth_event_check_arg_fn);
1045 	if (ret)
1046 		return ret;
1047 
1048 	if (++cmd->n_fields > SYNTH_FIELDS_MAX)
1049 		ret = -EINVAL;
1050 
1051 	return ret;
1052 }
1053 EXPORT_SYMBOL_GPL(synth_event_add_field);
1054 
1055 /**
1056  * synth_event_add_field_str - Add a new field to a synthetic event cmd
1057  * @cmd: A pointer to the dynevent_cmd struct representing the new event
1058  * @type_name: The type and name of the new field to add, as a single string
1059  *
1060  * Add a new field to a synthetic event cmd object, as a single
1061  * string.  The @type_name string is expected to be of the form 'type
1062  * name', which will be appended by ';'.  No sanity checking is done -
1063  * what's passed in is assumed to already be well-formed.  Field
1064  * ordering is in the same order the fields are added.
1065  *
1066  * See synth_field_size() for available types. If field_name contains
1067  * [n] the field is considered to be an array.
1068  *
1069  * Return: 0 if successful, error otherwise.
1070  */
1071 int synth_event_add_field_str(struct dynevent_cmd *cmd, const char *type_name)
1072 {
1073 	struct dynevent_arg arg;
1074 	int ret;
1075 
1076 	if (cmd->type != DYNEVENT_TYPE_SYNTH)
1077 		return -EINVAL;
1078 
1079 	if (!type_name)
1080 		return -EINVAL;
1081 
1082 	dynevent_arg_init(&arg, ';');
1083 
1084 	arg.str = type_name;
1085 
1086 	ret = dynevent_arg_add(cmd, &arg, NULL);
1087 	if (ret)
1088 		return ret;
1089 
1090 	if (++cmd->n_fields > SYNTH_FIELDS_MAX)
1091 		ret = -EINVAL;
1092 
1093 	return ret;
1094 }
1095 EXPORT_SYMBOL_GPL(synth_event_add_field_str);
1096 
1097 /**
1098  * synth_event_add_fields - Add multiple fields to a synthetic event cmd
1099  * @cmd: A pointer to the dynevent_cmd struct representing the new event
1100  * @fields: An array of type/name field descriptions
1101  * @n_fields: The number of field descriptions contained in the fields array
1102  *
1103  * Add a new set of fields to a synthetic event cmd object.  The event
1104  * fields that will be defined for the event should be passed in as an
1105  * array of struct synth_field_desc, and the number of elements in the
1106  * array passed in as n_fields.  Field ordering will retain the
1107  * ordering given in the fields array.
1108  *
1109  * See synth_field_size() for available types. If field_name contains
1110  * [n] the field is considered to be an array.
1111  *
1112  * Return: 0 if successful, error otherwise.
1113  */
1114 int synth_event_add_fields(struct dynevent_cmd *cmd,
1115 			   struct synth_field_desc *fields,
1116 			   unsigned int n_fields)
1117 {
1118 	unsigned int i;
1119 	int ret = 0;
1120 
1121 	for (i = 0; i < n_fields; i++) {
1122 		if (fields[i].type == NULL || fields[i].name == NULL) {
1123 			ret = -EINVAL;
1124 			break;
1125 		}
1126 
1127 		ret = synth_event_add_field(cmd, fields[i].type, fields[i].name);
1128 		if (ret)
1129 			break;
1130 	}
1131 
1132 	return ret;
1133 }
1134 EXPORT_SYMBOL_GPL(synth_event_add_fields);
1135 
1136 /**
1137  * __synth_event_gen_cmd_start - Start a synthetic event command from arg list
1138  * @cmd: A pointer to the dynevent_cmd struct representing the new event
1139  * @name: The name of the synthetic event
1140  * @mod: The module creating the event, NULL if not created from a module
1141  * @args: Variable number of arg (pairs), one pair for each field
1142  *
1143  * NOTE: Users normally won't want to call this function directly, but
1144  * rather use the synth_event_gen_cmd_start() wrapper, which
1145  * automatically adds a NULL to the end of the arg list.  If this
1146  * function is used directly, make sure the last arg in the variable
1147  * arg list is NULL.
1148  *
1149  * Generate a synthetic event command to be executed by
1150  * synth_event_gen_cmd_end().  This function can be used to generate
1151  * the complete command or only the first part of it; in the latter
1152  * case, synth_event_add_field(), synth_event_add_field_str(), or
1153  * synth_event_add_fields() can be used to add more fields following
1154  * this.
1155  *
1156  * There should be an even number variable args, each pair consisting
1157  * of a type followed by a field name.
1158  *
1159  * See synth_field_size() for available types. If field_name contains
1160  * [n] the field is considered to be an array.
1161  *
1162  * Return: 0 if successful, error otherwise.
1163  */
1164 int __synth_event_gen_cmd_start(struct dynevent_cmd *cmd, const char *name,
1165 				struct module *mod, ...)
1166 {
1167 	struct dynevent_arg arg;
1168 	va_list args;
1169 	int ret;
1170 
1171 	cmd->event_name = name;
1172 	cmd->private_data = mod;
1173 
1174 	if (cmd->type != DYNEVENT_TYPE_SYNTH)
1175 		return -EINVAL;
1176 
1177 	dynevent_arg_init(&arg, 0);
1178 	arg.str = name;
1179 	ret = dynevent_arg_add(cmd, &arg, NULL);
1180 	if (ret)
1181 		return ret;
1182 
1183 	va_start(args, mod);
1184 	for (;;) {
1185 		const char *type, *name;
1186 
1187 		type = va_arg(args, const char *);
1188 		if (!type)
1189 			break;
1190 		name = va_arg(args, const char *);
1191 		if (!name)
1192 			break;
1193 
1194 		if (++cmd->n_fields > SYNTH_FIELDS_MAX) {
1195 			ret = -EINVAL;
1196 			break;
1197 		}
1198 
1199 		ret = synth_event_add_field(cmd, type, name);
1200 		if (ret)
1201 			break;
1202 	}
1203 	va_end(args);
1204 
1205 	return ret;
1206 }
1207 EXPORT_SYMBOL_GPL(__synth_event_gen_cmd_start);
1208 
1209 /**
1210  * synth_event_gen_cmd_array_start - Start synthetic event command from an array
1211  * @cmd: A pointer to the dynevent_cmd struct representing the new event
1212  * @name: The name of the synthetic event
1213  * @mod: The module creating the event, NULL if not created from a module
1214  * @fields: An array of type/name field descriptions
1215  * @n_fields: The number of field descriptions contained in the fields array
1216  *
1217  * Generate a synthetic event command to be executed by
1218  * synth_event_gen_cmd_end().  This function can be used to generate
1219  * the complete command or only the first part of it; in the latter
1220  * case, synth_event_add_field(), synth_event_add_field_str(), or
1221  * synth_event_add_fields() can be used to add more fields following
1222  * this.
1223  *
1224  * The event fields that will be defined for the event should be
1225  * passed in as an array of struct synth_field_desc, and the number of
1226  * elements in the array passed in as n_fields.  Field ordering will
1227  * retain the ordering given in the fields array.
1228  *
1229  * See synth_field_size() for available types. If field_name contains
1230  * [n] the field is considered to be an array.
1231  *
1232  * Return: 0 if successful, error otherwise.
1233  */
1234 int synth_event_gen_cmd_array_start(struct dynevent_cmd *cmd, const char *name,
1235 				    struct module *mod,
1236 				    struct synth_field_desc *fields,
1237 				    unsigned int n_fields)
1238 {
1239 	struct dynevent_arg arg;
1240 	unsigned int i;
1241 	int ret = 0;
1242 
1243 	cmd->event_name = name;
1244 	cmd->private_data = mod;
1245 
1246 	if (cmd->type != DYNEVENT_TYPE_SYNTH)
1247 		return -EINVAL;
1248 
1249 	if (n_fields > SYNTH_FIELDS_MAX)
1250 		return -EINVAL;
1251 
1252 	dynevent_arg_init(&arg, 0);
1253 	arg.str = name;
1254 	ret = dynevent_arg_add(cmd, &arg, NULL);
1255 	if (ret)
1256 		return ret;
1257 
1258 	for (i = 0; i < n_fields; i++) {
1259 		if (fields[i].type == NULL || fields[i].name == NULL)
1260 			return -EINVAL;
1261 
1262 		ret = synth_event_add_field(cmd, fields[i].type, fields[i].name);
1263 		if (ret)
1264 			break;
1265 	}
1266 
1267 	return ret;
1268 }
1269 EXPORT_SYMBOL_GPL(synth_event_gen_cmd_array_start);
1270 
1271 static int __create_synth_event(const char *name, const char *raw_fields)
1272 {
1273 	char **argv, *field_str, *tmp_fields, *saved_fields = NULL;
1274 	struct synth_field *field, *fields[SYNTH_FIELDS_MAX];
1275 	int consumed, cmd_version = 1, n_fields_this_loop;
1276 	int i, argc, n_fields = 0, ret = 0;
1277 	struct synth_event *event = NULL;
1278 
1279 	/*
1280 	 * Argument syntax:
1281 	 *  - Add synthetic event: <event_name> field[;field] ...
1282 	 *  - Remove synthetic event: !<event_name> field[;field] ...
1283 	 *      where 'field' = type field_name
1284 	 */
1285 
1286 	if (name[0] == '\0') {
1287 		synth_err(SYNTH_ERR_INVALID_CMD, 0);
1288 		return -EINVAL;
1289 	}
1290 
1291 	if (!is_good_name(name)) {
1292 		synth_err(SYNTH_ERR_BAD_NAME, errpos(name));
1293 		return -EINVAL;
1294 	}
1295 
1296 	mutex_lock(&event_mutex);
1297 
1298 	event = find_synth_event(name);
1299 	if (event) {
1300 		synth_err(SYNTH_ERR_EVENT_EXISTS, errpos(name));
1301 		ret = -EEXIST;
1302 		goto err;
1303 	}
1304 
1305 	tmp_fields = saved_fields = kstrdup(raw_fields, GFP_KERNEL);
1306 	if (!tmp_fields) {
1307 		ret = -ENOMEM;
1308 		goto err;
1309 	}
1310 
1311 	while ((field_str = strsep(&tmp_fields, ";")) != NULL) {
1312 		argv = argv_split(GFP_KERNEL, field_str, &argc);
1313 		if (!argv) {
1314 			ret = -ENOMEM;
1315 			goto err;
1316 		}
1317 
1318 		if (!argc) {
1319 			argv_free(argv);
1320 			continue;
1321 		}
1322 
1323 		n_fields_this_loop = 0;
1324 		consumed = 0;
1325 		while (argc > consumed) {
1326 			int field_version;
1327 
1328 			field = parse_synth_field(argc - consumed,
1329 						  argv + consumed, &consumed,
1330 						  &field_version);
1331 			if (IS_ERR(field)) {
1332 				ret = PTR_ERR(field);
1333 				goto err_free_arg;
1334 			}
1335 
1336 			/*
1337 			 * Track the highest version of any field we
1338 			 * found in the command.
1339 			 */
1340 			if (field_version > cmd_version)
1341 				cmd_version = field_version;
1342 
1343 			/*
1344 			 * Now sort out what is and isn't valid for
1345 			 * each supported version.
1346 			 *
1347 			 * If we see more than 1 field per loop, it
1348 			 * means we have multiple fields between
1349 			 * semicolons, and that's something we no
1350 			 * longer support in a version 2 or greater
1351 			 * command.
1352 			 */
1353 			if (cmd_version > 1 && n_fields_this_loop >= 1) {
1354 				synth_err(SYNTH_ERR_INVALID_CMD, errpos(field_str));
1355 				ret = -EINVAL;
1356 				goto err_free_arg;
1357 			}
1358 
1359 			if (n_fields == SYNTH_FIELDS_MAX) {
1360 				synth_err(SYNTH_ERR_TOO_MANY_FIELDS, 0);
1361 				ret = -EINVAL;
1362 				goto err_free_arg;
1363 			}
1364 			fields[n_fields++] = field;
1365 
1366 			n_fields_this_loop++;
1367 		}
1368 		argv_free(argv);
1369 
1370 		if (consumed < argc) {
1371 			synth_err(SYNTH_ERR_INVALID_CMD, 0);
1372 			ret = -EINVAL;
1373 			goto err;
1374 		}
1375 
1376 	}
1377 
1378 	if (n_fields == 0) {
1379 		synth_err(SYNTH_ERR_INVALID_CMD, 0);
1380 		ret = -EINVAL;
1381 		goto err;
1382 	}
1383 
1384 	event = alloc_synth_event(name, n_fields, fields);
1385 	if (IS_ERR(event)) {
1386 		ret = PTR_ERR(event);
1387 		event = NULL;
1388 		goto err;
1389 	}
1390 	ret = register_synth_event(event);
1391 	if (!ret)
1392 		dyn_event_add(&event->devent, &event->call);
1393 	else
1394 		free_synth_event(event);
1395  out:
1396 	mutex_unlock(&event_mutex);
1397 
1398 	kfree(saved_fields);
1399 
1400 	return ret;
1401  err_free_arg:
1402 	argv_free(argv);
1403  err:
1404 	for (i = 0; i < n_fields; i++)
1405 		free_synth_field(fields[i]);
1406 
1407 	goto out;
1408 }
1409 
1410 /**
1411  * synth_event_create - Create a new synthetic event
1412  * @name: The name of the new synthetic event
1413  * @fields: An array of type/name field descriptions
1414  * @n_fields: The number of field descriptions contained in the fields array
1415  * @mod: The module creating the event, NULL if not created from a module
1416  *
1417  * Create a new synthetic event with the given name under the
1418  * trace/events/synthetic/ directory.  The event fields that will be
1419  * defined for the event should be passed in as an array of struct
1420  * synth_field_desc, and the number elements in the array passed in as
1421  * n_fields. Field ordering will retain the ordering given in the
1422  * fields array.
1423  *
1424  * If the new synthetic event is being created from a module, the mod
1425  * param must be non-NULL.  This will ensure that the trace buffer
1426  * won't contain unreadable events.
1427  *
1428  * The new synth event should be deleted using synth_event_delete()
1429  * function.  The new synthetic event can be generated from modules or
1430  * other kernel code using trace_synth_event() and related functions.
1431  *
1432  * Return: 0 if successful, error otherwise.
1433  */
1434 int synth_event_create(const char *name, struct synth_field_desc *fields,
1435 		       unsigned int n_fields, struct module *mod)
1436 {
1437 	struct dynevent_cmd cmd;
1438 	char *buf;
1439 	int ret;
1440 
1441 	buf = kzalloc(MAX_DYNEVENT_CMD_LEN, GFP_KERNEL);
1442 	if (!buf)
1443 		return -ENOMEM;
1444 
1445 	synth_event_cmd_init(&cmd, buf, MAX_DYNEVENT_CMD_LEN);
1446 
1447 	ret = synth_event_gen_cmd_array_start(&cmd, name, mod,
1448 					      fields, n_fields);
1449 	if (ret)
1450 		goto out;
1451 
1452 	ret = synth_event_gen_cmd_end(&cmd);
1453  out:
1454 	kfree(buf);
1455 
1456 	return ret;
1457 }
1458 EXPORT_SYMBOL_GPL(synth_event_create);
1459 
1460 static int destroy_synth_event(struct synth_event *se)
1461 {
1462 	int ret;
1463 
1464 	if (se->ref)
1465 		return -EBUSY;
1466 
1467 	if (trace_event_dyn_busy(&se->call))
1468 		return -EBUSY;
1469 
1470 	ret = unregister_synth_event(se);
1471 	if (!ret) {
1472 		dyn_event_remove(&se->devent);
1473 		free_synth_event(se);
1474 	}
1475 
1476 	return ret;
1477 }
1478 
1479 /**
1480  * synth_event_delete - Delete a synthetic event
1481  * @event_name: The name of the new synthetic event
1482  *
1483  * Delete a synthetic event that was created with synth_event_create().
1484  *
1485  * Return: 0 if successful, error otherwise.
1486  */
1487 int synth_event_delete(const char *event_name)
1488 {
1489 	struct synth_event *se = NULL;
1490 	struct module *mod = NULL;
1491 	int ret = -ENOENT;
1492 
1493 	mutex_lock(&event_mutex);
1494 	se = find_synth_event(event_name);
1495 	if (se) {
1496 		mod = se->mod;
1497 		ret = destroy_synth_event(se);
1498 	}
1499 	mutex_unlock(&event_mutex);
1500 
1501 	if (mod) {
1502 		/*
1503 		 * It is safest to reset the ring buffer if the module
1504 		 * being unloaded registered any events that were
1505 		 * used. The only worry is if a new module gets
1506 		 * loaded, and takes on the same id as the events of
1507 		 * this module. When printing out the buffer, traced
1508 		 * events left over from this module may be passed to
1509 		 * the new module events and unexpected results may
1510 		 * occur.
1511 		 */
1512 		tracing_reset_all_online_cpus();
1513 	}
1514 
1515 	return ret;
1516 }
1517 EXPORT_SYMBOL_GPL(synth_event_delete);
1518 
1519 static int check_command(const char *raw_command)
1520 {
1521 	char **argv = NULL, *cmd, *saved_cmd, *name_and_field;
1522 	int argc, ret = 0;
1523 
1524 	cmd = saved_cmd = kstrdup(raw_command, GFP_KERNEL);
1525 	if (!cmd)
1526 		return -ENOMEM;
1527 
1528 	name_and_field = strsep(&cmd, ";");
1529 	if (!name_and_field) {
1530 		ret = -EINVAL;
1531 		goto free;
1532 	}
1533 
1534 	if (name_and_field[0] == '!')
1535 		goto free;
1536 
1537 	argv = argv_split(GFP_KERNEL, name_and_field, &argc);
1538 	if (!argv) {
1539 		ret = -ENOMEM;
1540 		goto free;
1541 	}
1542 	argv_free(argv);
1543 
1544 	if (argc < 3)
1545 		ret = -EINVAL;
1546 free:
1547 	kfree(saved_cmd);
1548 
1549 	return ret;
1550 }
1551 
1552 static int create_or_delete_synth_event(const char *raw_command)
1553 {
1554 	char *name = NULL, *fields, *p;
1555 	int ret = 0;
1556 
1557 	raw_command = skip_spaces(raw_command);
1558 	if (raw_command[0] == '\0')
1559 		return ret;
1560 
1561 	last_cmd_set(raw_command);
1562 
1563 	ret = check_command(raw_command);
1564 	if (ret) {
1565 		synth_err(SYNTH_ERR_INVALID_CMD, 0);
1566 		return ret;
1567 	}
1568 
1569 	p = strpbrk(raw_command, " \t");
1570 	if (!p && raw_command[0] != '!') {
1571 		synth_err(SYNTH_ERR_INVALID_CMD, 0);
1572 		ret = -EINVAL;
1573 		goto free;
1574 	}
1575 
1576 	name = kmemdup_nul(raw_command, p ? p - raw_command : strlen(raw_command), GFP_KERNEL);
1577 	if (!name)
1578 		return -ENOMEM;
1579 
1580 	if (name[0] == '!') {
1581 		ret = synth_event_delete(name + 1);
1582 		goto free;
1583 	}
1584 
1585 	fields = skip_spaces(p);
1586 
1587 	ret = __create_synth_event(name, fields);
1588 free:
1589 	kfree(name);
1590 
1591 	return ret;
1592 }
1593 
1594 static int synth_event_run_command(struct dynevent_cmd *cmd)
1595 {
1596 	struct synth_event *se;
1597 	int ret;
1598 
1599 	ret = create_or_delete_synth_event(cmd->seq.buffer);
1600 	if (ret)
1601 		return ret;
1602 
1603 	se = find_synth_event(cmd->event_name);
1604 	if (WARN_ON(!se))
1605 		return -ENOENT;
1606 
1607 	se->mod = cmd->private_data;
1608 
1609 	return ret;
1610 }
1611 
1612 /**
1613  * synth_event_cmd_init - Initialize a synthetic event command object
1614  * @cmd: A pointer to the dynevent_cmd struct representing the new event
1615  * @buf: A pointer to the buffer used to build the command
1616  * @maxlen: The length of the buffer passed in @buf
1617  *
1618  * Initialize a synthetic event command object.  Use this before
1619  * calling any of the other dyenvent_cmd functions.
1620  */
1621 void synth_event_cmd_init(struct dynevent_cmd *cmd, char *buf, int maxlen)
1622 {
1623 	dynevent_cmd_init(cmd, buf, maxlen, DYNEVENT_TYPE_SYNTH,
1624 			  synth_event_run_command);
1625 }
1626 EXPORT_SYMBOL_GPL(synth_event_cmd_init);
1627 
1628 static inline int
1629 __synth_event_trace_init(struct trace_event_file *file,
1630 			 struct synth_event_trace_state *trace_state)
1631 {
1632 	int ret = 0;
1633 
1634 	memset(trace_state, '\0', sizeof(*trace_state));
1635 
1636 	/*
1637 	 * Normal event tracing doesn't get called at all unless the
1638 	 * ENABLED bit is set (which attaches the probe thus allowing
1639 	 * this code to be called, etc).  Because this is called
1640 	 * directly by the user, we don't have that but we still need
1641 	 * to honor not logging when disabled.  For the iterated
1642 	 * trace case, we save the enabled state upon start and just
1643 	 * ignore the following data calls.
1644 	 */
1645 	if (!(file->flags & EVENT_FILE_FL_ENABLED) ||
1646 	    trace_trigger_soft_disabled(file)) {
1647 		trace_state->disabled = true;
1648 		ret = -ENOENT;
1649 		goto out;
1650 	}
1651 
1652 	trace_state->event = file->event_call->data;
1653 out:
1654 	return ret;
1655 }
1656 
1657 static inline int
1658 __synth_event_trace_start(struct trace_event_file *file,
1659 			  struct synth_event_trace_state *trace_state,
1660 			  int dynamic_fields_size)
1661 {
1662 	int entry_size, fields_size = 0;
1663 	int ret = 0;
1664 
1665 	fields_size = trace_state->event->n_u64 * sizeof(u64);
1666 	fields_size += dynamic_fields_size;
1667 
1668 	/*
1669 	 * Avoid ring buffer recursion detection, as this event
1670 	 * is being performed within another event.
1671 	 */
1672 	trace_state->buffer = file->tr->array_buffer.buffer;
1673 	ring_buffer_nest_start(trace_state->buffer);
1674 
1675 	entry_size = sizeof(*trace_state->entry) + fields_size;
1676 	trace_state->entry = trace_event_buffer_reserve(&trace_state->fbuffer,
1677 							file,
1678 							entry_size);
1679 	if (!trace_state->entry) {
1680 		ring_buffer_nest_end(trace_state->buffer);
1681 		ret = -EINVAL;
1682 	}
1683 
1684 	return ret;
1685 }
1686 
1687 static inline void
1688 __synth_event_trace_end(struct synth_event_trace_state *trace_state)
1689 {
1690 	trace_event_buffer_commit(&trace_state->fbuffer);
1691 
1692 	ring_buffer_nest_end(trace_state->buffer);
1693 }
1694 
1695 /**
1696  * synth_event_trace - Trace a synthetic event
1697  * @file: The trace_event_file representing the synthetic event
1698  * @n_vals: The number of values in vals
1699  * @args: Variable number of args containing the event values
1700  *
1701  * Trace a synthetic event using the values passed in the variable
1702  * argument list.
1703  *
1704  * The argument list should be a list 'n_vals' u64 values.  The number
1705  * of vals must match the number of field in the synthetic event, and
1706  * must be in the same order as the synthetic event fields.
1707  *
1708  * All vals should be cast to u64, and string vals are just pointers
1709  * to strings, cast to u64.  Strings will be copied into space
1710  * reserved in the event for the string, using these pointers.
1711  *
1712  * Return: 0 on success, err otherwise.
1713  */
1714 int synth_event_trace(struct trace_event_file *file, unsigned int n_vals, ...)
1715 {
1716 	unsigned int i, n_u64, len, data_size = 0;
1717 	struct synth_event_trace_state state;
1718 	va_list args;
1719 	int ret;
1720 
1721 	ret = __synth_event_trace_init(file, &state);
1722 	if (ret) {
1723 		if (ret == -ENOENT)
1724 			ret = 0; /* just disabled, not really an error */
1725 		return ret;
1726 	}
1727 
1728 	if (state.event->n_dynamic_fields) {
1729 		va_start(args, n_vals);
1730 
1731 		for (i = 0; i < state.event->n_fields; i++) {
1732 			u64 val = va_arg(args, u64);
1733 
1734 			if (state.event->fields[i]->is_string &&
1735 			    state.event->fields[i]->is_dynamic) {
1736 				char *str_val = (char *)(long)val;
1737 
1738 				data_size += strlen(str_val) + 1;
1739 			}
1740 		}
1741 
1742 		va_end(args);
1743 	}
1744 
1745 	ret = __synth_event_trace_start(file, &state, data_size);
1746 	if (ret)
1747 		return ret;
1748 
1749 	if (n_vals != state.event->n_fields) {
1750 		ret = -EINVAL;
1751 		goto out;
1752 	}
1753 
1754 	data_size = 0;
1755 
1756 	va_start(args, n_vals);
1757 	for (i = 0, n_u64 = 0; i < state.event->n_fields; i++) {
1758 		u64 val;
1759 
1760 		val = va_arg(args, u64);
1761 
1762 		if (state.event->fields[i]->is_string) {
1763 			char *str_val = (char *)(long)val;
1764 
1765 			len = trace_string(state.entry, state.event, str_val,
1766 					   state.event->fields[i]->is_dynamic,
1767 					   data_size, &n_u64);
1768 			data_size += len; /* only dynamic string increments */
1769 		} else {
1770 			struct synth_field *field = state.event->fields[i];
1771 
1772 			switch (field->size) {
1773 			case 1:
1774 				state.entry->fields[n_u64].as_u8 = (u8)val;
1775 				break;
1776 
1777 			case 2:
1778 				state.entry->fields[n_u64].as_u16 = (u16)val;
1779 				break;
1780 
1781 			case 4:
1782 				state.entry->fields[n_u64].as_u32 = (u32)val;
1783 				break;
1784 
1785 			default:
1786 				state.entry->fields[n_u64].as_u64 = val;
1787 				break;
1788 			}
1789 			n_u64++;
1790 		}
1791 	}
1792 	va_end(args);
1793 out:
1794 	__synth_event_trace_end(&state);
1795 
1796 	return ret;
1797 }
1798 EXPORT_SYMBOL_GPL(synth_event_trace);
1799 
1800 /**
1801  * synth_event_trace_array - Trace a synthetic event from an array
1802  * @file: The trace_event_file representing the synthetic event
1803  * @vals: Array of values
1804  * @n_vals: The number of values in vals
1805  *
1806  * Trace a synthetic event using the values passed in as 'vals'.
1807  *
1808  * The 'vals' array is just an array of 'n_vals' u64.  The number of
1809  * vals must match the number of field in the synthetic event, and
1810  * must be in the same order as the synthetic event fields.
1811  *
1812  * All vals should be cast to u64, and string vals are just pointers
1813  * to strings, cast to u64.  Strings will be copied into space
1814  * reserved in the event for the string, using these pointers.
1815  *
1816  * Return: 0 on success, err otherwise.
1817  */
1818 int synth_event_trace_array(struct trace_event_file *file, u64 *vals,
1819 			    unsigned int n_vals)
1820 {
1821 	unsigned int i, n_u64, field_pos, len, data_size = 0;
1822 	struct synth_event_trace_state state;
1823 	char *str_val;
1824 	int ret;
1825 
1826 	ret = __synth_event_trace_init(file, &state);
1827 	if (ret) {
1828 		if (ret == -ENOENT)
1829 			ret = 0; /* just disabled, not really an error */
1830 		return ret;
1831 	}
1832 
1833 	if (state.event->n_dynamic_fields) {
1834 		for (i = 0; i < state.event->n_dynamic_fields; i++) {
1835 			field_pos = state.event->dynamic_fields[i]->field_pos;
1836 			str_val = (char *)(long)vals[field_pos];
1837 			len = strlen(str_val) + 1;
1838 			data_size += len;
1839 		}
1840 	}
1841 
1842 	ret = __synth_event_trace_start(file, &state, data_size);
1843 	if (ret)
1844 		return ret;
1845 
1846 	if (n_vals != state.event->n_fields) {
1847 		ret = -EINVAL;
1848 		goto out;
1849 	}
1850 
1851 	data_size = 0;
1852 
1853 	for (i = 0, n_u64 = 0; i < state.event->n_fields; i++) {
1854 		if (state.event->fields[i]->is_string) {
1855 			char *str_val = (char *)(long)vals[i];
1856 
1857 			len = trace_string(state.entry, state.event, str_val,
1858 					   state.event->fields[i]->is_dynamic,
1859 					   data_size, &n_u64);
1860 			data_size += len; /* only dynamic string increments */
1861 		} else {
1862 			struct synth_field *field = state.event->fields[i];
1863 			u64 val = vals[i];
1864 
1865 			switch (field->size) {
1866 			case 1:
1867 				state.entry->fields[n_u64].as_u8 = (u8)val;
1868 				break;
1869 
1870 			case 2:
1871 				state.entry->fields[n_u64].as_u16 = (u16)val;
1872 				break;
1873 
1874 			case 4:
1875 				state.entry->fields[n_u64].as_u32 = (u32)val;
1876 				break;
1877 
1878 			default:
1879 				state.entry->fields[n_u64].as_u64 = val;
1880 				break;
1881 			}
1882 			n_u64++;
1883 		}
1884 	}
1885 out:
1886 	__synth_event_trace_end(&state);
1887 
1888 	return ret;
1889 }
1890 EXPORT_SYMBOL_GPL(synth_event_trace_array);
1891 
1892 /**
1893  * synth_event_trace_start - Start piecewise synthetic event trace
1894  * @file: The trace_event_file representing the synthetic event
1895  * @trace_state: A pointer to object tracking the piecewise trace state
1896  *
1897  * Start the trace of a synthetic event field-by-field rather than all
1898  * at once.
1899  *
1900  * This function 'opens' an event trace, which means space is reserved
1901  * for the event in the trace buffer, after which the event's
1902  * individual field values can be set through either
1903  * synth_event_add_next_val() or synth_event_add_val().
1904  *
1905  * A pointer to a trace_state object is passed in, which will keep
1906  * track of the current event trace state until the event trace is
1907  * closed (and the event finally traced) using
1908  * synth_event_trace_end().
1909  *
1910  * Note that synth_event_trace_end() must be called after all values
1911  * have been added for each event trace, regardless of whether adding
1912  * all field values succeeded or not.
1913  *
1914  * Note also that for a given event trace, all fields must be added
1915  * using either synth_event_add_next_val() or synth_event_add_val()
1916  * but not both together or interleaved.
1917  *
1918  * Return: 0 on success, err otherwise.
1919  */
1920 int synth_event_trace_start(struct trace_event_file *file,
1921 			    struct synth_event_trace_state *trace_state)
1922 {
1923 	int ret;
1924 
1925 	if (!trace_state)
1926 		return -EINVAL;
1927 
1928 	ret = __synth_event_trace_init(file, trace_state);
1929 	if (ret) {
1930 		if (ret == -ENOENT)
1931 			ret = 0; /* just disabled, not really an error */
1932 		return ret;
1933 	}
1934 
1935 	if (trace_state->event->n_dynamic_fields)
1936 		return -ENOTSUPP;
1937 
1938 	ret = __synth_event_trace_start(file, trace_state, 0);
1939 
1940 	return ret;
1941 }
1942 EXPORT_SYMBOL_GPL(synth_event_trace_start);
1943 
1944 static int __synth_event_add_val(const char *field_name, u64 val,
1945 				 struct synth_event_trace_state *trace_state)
1946 {
1947 	struct synth_field *field = NULL;
1948 	struct synth_trace_event *entry;
1949 	struct synth_event *event;
1950 	int i, ret = 0;
1951 
1952 	if (!trace_state) {
1953 		ret = -EINVAL;
1954 		goto out;
1955 	}
1956 
1957 	/* can't mix add_next_synth_val() with add_synth_val() */
1958 	if (field_name) {
1959 		if (trace_state->add_next) {
1960 			ret = -EINVAL;
1961 			goto out;
1962 		}
1963 		trace_state->add_name = true;
1964 	} else {
1965 		if (trace_state->add_name) {
1966 			ret = -EINVAL;
1967 			goto out;
1968 		}
1969 		trace_state->add_next = true;
1970 	}
1971 
1972 	if (trace_state->disabled)
1973 		goto out;
1974 
1975 	event = trace_state->event;
1976 	if (trace_state->add_name) {
1977 		for (i = 0; i < event->n_fields; i++) {
1978 			field = event->fields[i];
1979 			if (strcmp(field->name, field_name) == 0)
1980 				break;
1981 		}
1982 		if (!field) {
1983 			ret = -EINVAL;
1984 			goto out;
1985 		}
1986 	} else {
1987 		if (trace_state->cur_field >= event->n_fields) {
1988 			ret = -EINVAL;
1989 			goto out;
1990 		}
1991 		field = event->fields[trace_state->cur_field++];
1992 	}
1993 
1994 	entry = trace_state->entry;
1995 	if (field->is_string) {
1996 		char *str_val = (char *)(long)val;
1997 		char *str_field;
1998 
1999 		if (field->is_dynamic) { /* add_val can't do dynamic strings */
2000 			ret = -EINVAL;
2001 			goto out;
2002 		}
2003 
2004 		if (!str_val) {
2005 			ret = -EINVAL;
2006 			goto out;
2007 		}
2008 
2009 		str_field = (char *)&entry->fields[field->offset];
2010 		strscpy(str_field, str_val, STR_VAR_LEN_MAX);
2011 	} else {
2012 		switch (field->size) {
2013 		case 1:
2014 			trace_state->entry->fields[field->offset].as_u8 = (u8)val;
2015 			break;
2016 
2017 		case 2:
2018 			trace_state->entry->fields[field->offset].as_u16 = (u16)val;
2019 			break;
2020 
2021 		case 4:
2022 			trace_state->entry->fields[field->offset].as_u32 = (u32)val;
2023 			break;
2024 
2025 		default:
2026 			trace_state->entry->fields[field->offset].as_u64 = val;
2027 			break;
2028 		}
2029 	}
2030  out:
2031 	return ret;
2032 }
2033 
2034 /**
2035  * synth_event_add_next_val - Add the next field's value to an open synth trace
2036  * @val: The value to set the next field to
2037  * @trace_state: A pointer to object tracking the piecewise trace state
2038  *
2039  * Set the value of the next field in an event that's been opened by
2040  * synth_event_trace_start().
2041  *
2042  * The val param should be the value cast to u64.  If the value points
2043  * to a string, the val param should be a char * cast to u64.
2044  *
2045  * This function assumes all the fields in an event are to be set one
2046  * after another - successive calls to this function are made, one for
2047  * each field, in the order of the fields in the event, until all
2048  * fields have been set.  If you'd rather set each field individually
2049  * without regard to ordering, synth_event_add_val() can be used
2050  * instead.
2051  *
2052  * Note however that synth_event_add_next_val() and
2053  * synth_event_add_val() can't be intermixed for a given event trace -
2054  * one or the other but not both can be used at the same time.
2055  *
2056  * Note also that synth_event_trace_end() must be called after all
2057  * values have been added for each event trace, regardless of whether
2058  * adding all field values succeeded or not.
2059  *
2060  * Return: 0 on success, err otherwise.
2061  */
2062 int synth_event_add_next_val(u64 val,
2063 			     struct synth_event_trace_state *trace_state)
2064 {
2065 	return __synth_event_add_val(NULL, val, trace_state);
2066 }
2067 EXPORT_SYMBOL_GPL(synth_event_add_next_val);
2068 
2069 /**
2070  * synth_event_add_val - Add a named field's value to an open synth trace
2071  * @field_name: The name of the synthetic event field value to set
2072  * @val: The value to set the named field to
2073  * @trace_state: A pointer to object tracking the piecewise trace state
2074  *
2075  * Set the value of the named field in an event that's been opened by
2076  * synth_event_trace_start().
2077  *
2078  * The val param should be the value cast to u64.  If the value points
2079  * to a string, the val param should be a char * cast to u64.
2080  *
2081  * This function looks up the field name, and if found, sets the field
2082  * to the specified value.  This lookup makes this function more
2083  * expensive than synth_event_add_next_val(), so use that or the
2084  * none-piecewise synth_event_trace() instead if efficiency is more
2085  * important.
2086  *
2087  * Note however that synth_event_add_next_val() and
2088  * synth_event_add_val() can't be intermixed for a given event trace -
2089  * one or the other but not both can be used at the same time.
2090  *
2091  * Note also that synth_event_trace_end() must be called after all
2092  * values have been added for each event trace, regardless of whether
2093  * adding all field values succeeded or not.
2094  *
2095  * Return: 0 on success, err otherwise.
2096  */
2097 int synth_event_add_val(const char *field_name, u64 val,
2098 			struct synth_event_trace_state *trace_state)
2099 {
2100 	return __synth_event_add_val(field_name, val, trace_state);
2101 }
2102 EXPORT_SYMBOL_GPL(synth_event_add_val);
2103 
2104 /**
2105  * synth_event_trace_end - End piecewise synthetic event trace
2106  * @trace_state: A pointer to object tracking the piecewise trace state
2107  *
2108  * End the trace of a synthetic event opened by
2109  * synth_event_trace__start().
2110  *
2111  * This function 'closes' an event trace, which basically means that
2112  * it commits the reserved event and cleans up other loose ends.
2113  *
2114  * A pointer to a trace_state object is passed in, which will keep
2115  * track of the current event trace state opened with
2116  * synth_event_trace_start().
2117  *
2118  * Note that this function must be called after all values have been
2119  * added for each event trace, regardless of whether adding all field
2120  * values succeeded or not.
2121  *
2122  * Return: 0 on success, err otherwise.
2123  */
2124 int synth_event_trace_end(struct synth_event_trace_state *trace_state)
2125 {
2126 	if (!trace_state)
2127 		return -EINVAL;
2128 
2129 	__synth_event_trace_end(trace_state);
2130 
2131 	return 0;
2132 }
2133 EXPORT_SYMBOL_GPL(synth_event_trace_end);
2134 
2135 static int create_synth_event(const char *raw_command)
2136 {
2137 	char *fields, *p;
2138 	const char *name;
2139 	int len, ret = 0;
2140 
2141 	raw_command = skip_spaces(raw_command);
2142 	if (raw_command[0] == '\0')
2143 		return ret;
2144 
2145 	last_cmd_set(raw_command);
2146 
2147 	name = raw_command;
2148 
2149 	/* Don't try to process if not our system */
2150 	if (name[0] != 's' || name[1] != ':')
2151 		return -ECANCELED;
2152 	name += 2;
2153 
2154 	p = strpbrk(raw_command, " \t");
2155 	if (!p) {
2156 		synth_err(SYNTH_ERR_INVALID_CMD, 0);
2157 		return -EINVAL;
2158 	}
2159 
2160 	fields = skip_spaces(p);
2161 
2162 	/* This interface accepts group name prefix */
2163 	if (strchr(name, '/')) {
2164 		len = str_has_prefix(name, SYNTH_SYSTEM "/");
2165 		if (len == 0) {
2166 			synth_err(SYNTH_ERR_INVALID_DYN_CMD, 0);
2167 			return -EINVAL;
2168 		}
2169 		name += len;
2170 	}
2171 
2172 	len = name - raw_command;
2173 
2174 	ret = check_command(raw_command + len);
2175 	if (ret) {
2176 		synth_err(SYNTH_ERR_INVALID_CMD, 0);
2177 		return ret;
2178 	}
2179 
2180 	name = kmemdup_nul(raw_command + len, p - raw_command - len, GFP_KERNEL);
2181 	if (!name)
2182 		return -ENOMEM;
2183 
2184 	ret = __create_synth_event(name, fields);
2185 
2186 	kfree(name);
2187 
2188 	return ret;
2189 }
2190 
2191 static int synth_event_release(struct dyn_event *ev)
2192 {
2193 	struct synth_event *event = to_synth_event(ev);
2194 	int ret;
2195 
2196 	if (event->ref)
2197 		return -EBUSY;
2198 
2199 	if (trace_event_dyn_busy(&event->call))
2200 		return -EBUSY;
2201 
2202 	ret = unregister_synth_event(event);
2203 	if (ret)
2204 		return ret;
2205 
2206 	dyn_event_remove(ev);
2207 	free_synth_event(event);
2208 	return 0;
2209 }
2210 
2211 static int __synth_event_show(struct seq_file *m, struct synth_event *event)
2212 {
2213 	struct synth_field *field;
2214 	unsigned int i;
2215 	char *type, *t;
2216 
2217 	seq_printf(m, "%s\t", event->name);
2218 
2219 	for (i = 0; i < event->n_fields; i++) {
2220 		field = event->fields[i];
2221 
2222 		type = field->type;
2223 		t = strstr(type, "__data_loc");
2224 		if (t) { /* __data_loc belongs in format but not event desc */
2225 			t += sizeof("__data_loc");
2226 			type = t;
2227 		}
2228 
2229 		/* parameter values */
2230 		seq_printf(m, "%s %s%s", type, field->name,
2231 			   i == event->n_fields - 1 ? "" : "; ");
2232 	}
2233 
2234 	seq_putc(m, '\n');
2235 
2236 	return 0;
2237 }
2238 
2239 static int synth_event_show(struct seq_file *m, struct dyn_event *ev)
2240 {
2241 	struct synth_event *event = to_synth_event(ev);
2242 
2243 	seq_printf(m, "s:%s/", event->class.system);
2244 
2245 	return __synth_event_show(m, event);
2246 }
2247 
2248 static int synth_events_seq_show(struct seq_file *m, void *v)
2249 {
2250 	struct dyn_event *ev = v;
2251 
2252 	if (!is_synth_event(ev))
2253 		return 0;
2254 
2255 	return __synth_event_show(m, to_synth_event(ev));
2256 }
2257 
2258 static const struct seq_operations synth_events_seq_op = {
2259 	.start	= dyn_event_seq_start,
2260 	.next	= dyn_event_seq_next,
2261 	.stop	= dyn_event_seq_stop,
2262 	.show	= synth_events_seq_show,
2263 };
2264 
2265 static int synth_events_open(struct inode *inode, struct file *file)
2266 {
2267 	int ret;
2268 
2269 	ret = security_locked_down(LOCKDOWN_TRACEFS);
2270 	if (ret)
2271 		return ret;
2272 
2273 	if ((file->f_mode & FMODE_WRITE) && (file->f_flags & O_TRUNC)) {
2274 		ret = dyn_events_release_all(&synth_event_ops);
2275 		if (ret < 0)
2276 			return ret;
2277 	}
2278 
2279 	return seq_open(file, &synth_events_seq_op);
2280 }
2281 
2282 static ssize_t synth_events_write(struct file *file,
2283 				  const char __user *buffer,
2284 				  size_t count, loff_t *ppos)
2285 {
2286 	return trace_parse_run_command(file, buffer, count, ppos,
2287 				       create_or_delete_synth_event);
2288 }
2289 
2290 static const struct file_operations synth_events_fops = {
2291 	.open           = synth_events_open,
2292 	.write		= synth_events_write,
2293 	.read           = seq_read,
2294 	.llseek         = seq_lseek,
2295 	.release        = seq_release,
2296 };
2297 
2298 /*
2299  * Register dynevent at core_initcall. This allows kernel to setup kprobe
2300  * events in postcore_initcall without tracefs.
2301  */
2302 static __init int trace_events_synth_init_early(void)
2303 {
2304 	int err = 0;
2305 
2306 	err = dyn_event_register(&synth_event_ops);
2307 	if (err)
2308 		pr_warn("Could not register synth_event_ops\n");
2309 
2310 	return err;
2311 }
2312 core_initcall(trace_events_synth_init_early);
2313 
2314 static __init int trace_events_synth_init(void)
2315 {
2316 	struct dentry *entry = NULL;
2317 	int err = 0;
2318 	err = tracing_init_dentry();
2319 	if (err)
2320 		goto err;
2321 
2322 	entry = tracefs_create_file("synthetic_events", TRACE_MODE_WRITE,
2323 				    NULL, NULL, &synth_events_fops);
2324 	if (!entry) {
2325 		err = -ENODEV;
2326 		goto err;
2327 	}
2328 
2329 	return err;
2330  err:
2331 	pr_warn("Could not create tracefs 'synthetic_events' entry\n");
2332 
2333 	return err;
2334 }
2335 
2336 fs_initcall(trace_events_synth_init);
2337