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