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 40enum { ERRORS }; 41 42#undef C 43#define C(a, b) b 44 45static const char *err_text[] = { ERRORS }; 46 47static DEFINE_MUTEX(lastcmd_mutex); 48static char *last_cmd; 49 50static 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 64static 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 75static 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 87static int create_synth_event(const char *raw_command); 88static int synth_event_show(struct seq_file *m, struct dyn_event *ev); 89static int synth_event_release(struct dyn_event *ev); 90static bool synth_event_is_busy(struct dyn_event *ev); 91static bool synth_event_match(const char *system, const char *event, 92 int argc, const char **argv, struct dyn_event *ev); 93 94static 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 102static bool is_synth_event(struct dyn_event *ev) 103{ 104 return ev->ops == &synth_event_ops; 105} 106 107static struct synth_event *to_synth_event(struct dyn_event *ev) 108{ 109 return container_of(ev, struct synth_event, devent); 110} 111 112static 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 119static 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 128struct synth_trace_event { 129 struct trace_entry ent; 130 union trace_synth_field fields[]; 131}; 132 133static 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 169static 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 179static int synth_field_is_string(char *type) 180{ 181 if (strstr(type, "char[") != NULL) 182 return true; 183 184 return false; 185} 186 187static int synth_field_is_stack(char *type) 188{ 189 if (strstr(type, "long[") != NULL) 190 return true; 191 192 return false; 193} 194 195static 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 230static 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 276static 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 322static 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 345static 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 } 420end: 421 trace_seq_putc(s, '\n'); 422 423 return trace_handle_return(s); 424} 425 426static struct trace_event_functions synth_event_funcs = { 427 .trace = print_synth_event 428}; 429 430static 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 470static 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 505static 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); 595out: 596 ring_buffer_nest_end(buffer); 597} 598 599static 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 607static 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 645static 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 665static void free_synth_field(struct synth_field *field) 666{ 667 kfree(field->type); 668 kfree(field->name); 669 kfree(field); 670} 671 672static 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 689static 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 814static void free_synth_tracepoint(struct tracepoint *tp) 815{ 816 if (!tp) 817 return; 818 819 kfree(tp->name); 820 kfree(tp); 821} 822 823static 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 840struct 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 856static struct trace_event_fields synth_event_fields_array[] = { 857 { .type = TRACE_FUNCTION_TYPE, 858 .define_fields = synth_event_define_fields }, 859 {} 860}; 861 862static 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 914static 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 924static 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 943static 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 999static 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 */ 1027int 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} 1053EXPORT_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 */ 1071int 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} 1095EXPORT_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 */ 1114int 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} 1134EXPORT_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 * @...: 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 */ 1164int __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} 1207EXPORT_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 */ 1234int 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} 1269EXPORT_SYMBOL_GPL(synth_event_gen_cmd_array_start); 1270 1271static 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 */ 1434int 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} 1458EXPORT_SYMBOL_GPL(synth_event_create); 1459 1460static 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 */ 1487int 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} 1517EXPORT_SYMBOL_GPL(synth_event_delete); 1518 1519static 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; 1546free: 1547 kfree(saved_cmd); 1548 1549 return ret; 1550} 1551 1552static 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); 1588free: 1589 kfree(name); 1590 1591 return ret; 1592} 1593 1594static 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 */ 1621void 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} 1626EXPORT_SYMBOL_GPL(synth_event_cmd_init); 1627 1628static 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; 1653out: 1654 return ret; 1655} 1656 1657static 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 1687static 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 * @...: 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 */ 1714int 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); 1793out: 1794 __synth_event_trace_end(&state); 1795 1796 return ret; 1797} 1798EXPORT_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 */ 1818int 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 } 1885out: 1886 __synth_event_trace_end(&state); 1887 1888 return ret; 1889} 1890EXPORT_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 */ 1920int 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} 1942EXPORT_SYMBOL_GPL(synth_event_trace_start); 1943 1944static 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 */ 2062int 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} 2067EXPORT_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 */ 2097int 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} 2102EXPORT_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 */ 2124int 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} 2133EXPORT_SYMBOL_GPL(synth_event_trace_end); 2134 2135static 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 2191static 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 2211static 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 2239static 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 2248static 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 2258static 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 2265static 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 2282static 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 2290static 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 */ 2302static __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} 2312core_initcall(trace_events_synth_init_early); 2313 2314static __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 2336fs_initcall(trace_events_synth_init); 2337