1 /* 2 * Stage 1 of the trace events. 3 * 4 * Override the macros in <trace/trace_events.h> to include the following: 5 * 6 * struct ftrace_raw_<call> { 7 * struct trace_entry ent; 8 * <type> <item>; 9 * <type2> <item2>[<len>]; 10 * [...] 11 * }; 12 * 13 * The <type> <item> is created by the __field(type, item) macro or 14 * the __array(type2, item2, len) macro. 15 * We simply do "type item;", and that will create the fields 16 * in the structure. 17 */ 18 19 #include <linux/ftrace_event.h> 20 21 /* 22 * DECLARE_EVENT_CLASS can be used to add a generic function 23 * handlers for events. That is, if all events have the same 24 * parameters and just have distinct trace points. 25 * Each tracepoint can be defined with DEFINE_EVENT and that 26 * will map the DECLARE_EVENT_CLASS to the tracepoint. 27 * 28 * TRACE_EVENT is a one to one mapping between tracepoint and template. 29 */ 30 #undef TRACE_EVENT 31 #define TRACE_EVENT(name, proto, args, tstruct, assign, print) \ 32 DECLARE_EVENT_CLASS(name, \ 33 PARAMS(proto), \ 34 PARAMS(args), \ 35 PARAMS(tstruct), \ 36 PARAMS(assign), \ 37 PARAMS(print)); \ 38 DEFINE_EVENT(name, name, PARAMS(proto), PARAMS(args)); 39 40 41 #undef __field 42 #define __field(type, item) type item; 43 44 #undef __field_ext 45 #define __field_ext(type, item, filter_type) type item; 46 47 #undef __field_struct 48 #define __field_struct(type, item) type item; 49 50 #undef __field_struct_ext 51 #define __field_struct_ext(type, item, filter_type) type item; 52 53 #undef __array 54 #define __array(type, item, len) type item[len]; 55 56 #undef __dynamic_array 57 #define __dynamic_array(type, item, len) u32 __data_loc_##item; 58 59 #undef __string 60 #define __string(item, src) __dynamic_array(char, item, -1) 61 62 #undef __bitmask 63 #define __bitmask(item, nr_bits) __dynamic_array(char, item, -1) 64 65 #undef TP_STRUCT__entry 66 #define TP_STRUCT__entry(args...) args 67 68 #undef DECLARE_EVENT_CLASS 69 #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) \ 70 struct ftrace_raw_##name { \ 71 struct trace_entry ent; \ 72 tstruct \ 73 char __data[0]; \ 74 }; \ 75 \ 76 static struct ftrace_event_class event_class_##name; 77 78 #undef DEFINE_EVENT 79 #define DEFINE_EVENT(template, name, proto, args) \ 80 static struct ftrace_event_call __used \ 81 __attribute__((__aligned__(4))) event_##name 82 83 #undef DEFINE_EVENT_FN 84 #define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg) \ 85 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) 86 87 #undef DEFINE_EVENT_PRINT 88 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ 89 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) 90 91 /* Callbacks are meaningless to ftrace. */ 92 #undef TRACE_EVENT_FN 93 #define TRACE_EVENT_FN(name, proto, args, tstruct, \ 94 assign, print, reg, unreg) \ 95 TRACE_EVENT(name, PARAMS(proto), PARAMS(args), \ 96 PARAMS(tstruct), PARAMS(assign), PARAMS(print)) \ 97 98 #undef TRACE_EVENT_FLAGS 99 #define TRACE_EVENT_FLAGS(name, value) \ 100 __TRACE_EVENT_FLAGS(name, value) 101 102 #undef TRACE_EVENT_PERF_PERM 103 #define TRACE_EVENT_PERF_PERM(name, expr...) \ 104 __TRACE_EVENT_PERF_PERM(name, expr) 105 106 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) 107 108 109 /* 110 * Stage 2 of the trace events. 111 * 112 * Include the following: 113 * 114 * struct ftrace_data_offsets_<call> { 115 * u32 <item1>; 116 * u32 <item2>; 117 * [...] 118 * }; 119 * 120 * The __dynamic_array() macro will create each u32 <item>, this is 121 * to keep the offset of each array from the beginning of the event. 122 * The size of an array is also encoded, in the higher 16 bits of <item>. 123 */ 124 125 #undef __field 126 #define __field(type, item) 127 128 #undef __field_ext 129 #define __field_ext(type, item, filter_type) 130 131 #undef __field_struct 132 #define __field_struct(type, item) 133 134 #undef __field_struct_ext 135 #define __field_struct_ext(type, item, filter_type) 136 137 #undef __array 138 #define __array(type, item, len) 139 140 #undef __dynamic_array 141 #define __dynamic_array(type, item, len) u32 item; 142 143 #undef __string 144 #define __string(item, src) __dynamic_array(char, item, -1) 145 146 #undef __bitmask 147 #define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1) 148 149 #undef DECLARE_EVENT_CLASS 150 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \ 151 struct ftrace_data_offsets_##call { \ 152 tstruct; \ 153 }; 154 155 #undef DEFINE_EVENT 156 #define DEFINE_EVENT(template, name, proto, args) 157 158 #undef DEFINE_EVENT_PRINT 159 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ 160 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) 161 162 #undef TRACE_EVENT_FLAGS 163 #define TRACE_EVENT_FLAGS(event, flag) 164 165 #undef TRACE_EVENT_PERF_PERM 166 #define TRACE_EVENT_PERF_PERM(event, expr...) 167 168 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) 169 170 /* 171 * Stage 3 of the trace events. 172 * 173 * Override the macros in <trace/trace_events.h> to include the following: 174 * 175 * enum print_line_t 176 * ftrace_raw_output_<call>(struct trace_iterator *iter, int flags) 177 * { 178 * struct trace_seq *s = &iter->seq; 179 * struct ftrace_raw_<call> *field; <-- defined in stage 1 180 * struct trace_entry *entry; 181 * struct trace_seq *p = &iter->tmp_seq; 182 * int ret; 183 * 184 * entry = iter->ent; 185 * 186 * if (entry->type != event_<call>->event.type) { 187 * WARN_ON_ONCE(1); 188 * return TRACE_TYPE_UNHANDLED; 189 * } 190 * 191 * field = (typeof(field))entry; 192 * 193 * trace_seq_init(p); 194 * ret = trace_seq_printf(s, "%s: ", <call>); 195 * if (ret) 196 * ret = trace_seq_printf(s, <TP_printk> "\n"); 197 * if (!ret) 198 * return TRACE_TYPE_PARTIAL_LINE; 199 * 200 * return TRACE_TYPE_HANDLED; 201 * } 202 * 203 * This is the method used to print the raw event to the trace 204 * output format. Note, this is not needed if the data is read 205 * in binary. 206 */ 207 208 #undef __entry 209 #define __entry field 210 211 #undef TP_printk 212 #define TP_printk(fmt, args...) fmt "\n", args 213 214 #undef __get_dynamic_array 215 #define __get_dynamic_array(field) \ 216 ((void *)__entry + (__entry->__data_loc_##field & 0xffff)) 217 218 #undef __get_dynamic_array_len 219 #define __get_dynamic_array_len(field) \ 220 ((__entry->__data_loc_##field >> 16) & 0xffff) 221 222 #undef __get_str 223 #define __get_str(field) (char *)__get_dynamic_array(field) 224 225 #undef __get_bitmask 226 #define __get_bitmask(field) \ 227 ({ \ 228 void *__bitmask = __get_dynamic_array(field); \ 229 unsigned int __bitmask_size; \ 230 __bitmask_size = __get_dynamic_array_len(field); \ 231 ftrace_print_bitmask_seq(p, __bitmask, __bitmask_size); \ 232 }) 233 234 #undef __print_flags 235 #define __print_flags(flag, delim, flag_array...) \ 236 ({ \ 237 static const struct trace_print_flags __flags[] = \ 238 { flag_array, { -1, NULL }}; \ 239 ftrace_print_flags_seq(p, delim, flag, __flags); \ 240 }) 241 242 #undef __print_symbolic 243 #define __print_symbolic(value, symbol_array...) \ 244 ({ \ 245 static const struct trace_print_flags symbols[] = \ 246 { symbol_array, { -1, NULL }}; \ 247 ftrace_print_symbols_seq(p, value, symbols); \ 248 }) 249 250 #undef __print_symbolic_u64 251 #if BITS_PER_LONG == 32 252 #define __print_symbolic_u64(value, symbol_array...) \ 253 ({ \ 254 static const struct trace_print_flags_u64 symbols[] = \ 255 { symbol_array, { -1, NULL } }; \ 256 ftrace_print_symbols_seq_u64(p, value, symbols); \ 257 }) 258 #else 259 #define __print_symbolic_u64(value, symbol_array...) \ 260 __print_symbolic(value, symbol_array) 261 #endif 262 263 #undef __print_hex 264 #define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len) 265 266 #undef DECLARE_EVENT_CLASS 267 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \ 268 static notrace enum print_line_t \ 269 ftrace_raw_output_##call(struct trace_iterator *iter, int flags, \ 270 struct trace_event *trace_event) \ 271 { \ 272 struct trace_seq *s = &iter->seq; \ 273 struct trace_seq __maybe_unused *p = &iter->tmp_seq; \ 274 struct ftrace_raw_##call *field; \ 275 int ret; \ 276 \ 277 field = (typeof(field))iter->ent; \ 278 \ 279 ret = ftrace_raw_output_prep(iter, trace_event); \ 280 if (ret) \ 281 return ret; \ 282 \ 283 ret = trace_seq_printf(s, print); \ 284 if (!ret) \ 285 return TRACE_TYPE_PARTIAL_LINE; \ 286 \ 287 return TRACE_TYPE_HANDLED; \ 288 } \ 289 static struct trace_event_functions ftrace_event_type_funcs_##call = { \ 290 .trace = ftrace_raw_output_##call, \ 291 }; 292 293 #undef DEFINE_EVENT_PRINT 294 #define DEFINE_EVENT_PRINT(template, call, proto, args, print) \ 295 static notrace enum print_line_t \ 296 ftrace_raw_output_##call(struct trace_iterator *iter, int flags, \ 297 struct trace_event *event) \ 298 { \ 299 struct ftrace_raw_##template *field; \ 300 struct trace_entry *entry; \ 301 struct trace_seq *p = &iter->tmp_seq; \ 302 \ 303 entry = iter->ent; \ 304 \ 305 if (entry->type != event_##call.event.type) { \ 306 WARN_ON_ONCE(1); \ 307 return TRACE_TYPE_UNHANDLED; \ 308 } \ 309 \ 310 field = (typeof(field))entry; \ 311 \ 312 trace_seq_init(p); \ 313 return ftrace_output_call(iter, #call, print); \ 314 } \ 315 static struct trace_event_functions ftrace_event_type_funcs_##call = { \ 316 .trace = ftrace_raw_output_##call, \ 317 }; 318 319 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) 320 321 #undef __field_ext 322 #define __field_ext(type, item, filter_type) \ 323 ret = trace_define_field(event_call, #type, #item, \ 324 offsetof(typeof(field), item), \ 325 sizeof(field.item), \ 326 is_signed_type(type), filter_type); \ 327 if (ret) \ 328 return ret; 329 330 #undef __field_struct_ext 331 #define __field_struct_ext(type, item, filter_type) \ 332 ret = trace_define_field(event_call, #type, #item, \ 333 offsetof(typeof(field), item), \ 334 sizeof(field.item), \ 335 0, filter_type); \ 336 if (ret) \ 337 return ret; 338 339 #undef __field 340 #define __field(type, item) __field_ext(type, item, FILTER_OTHER) 341 342 #undef __field_struct 343 #define __field_struct(type, item) __field_struct_ext(type, item, FILTER_OTHER) 344 345 #undef __array 346 #define __array(type, item, len) \ 347 do { \ 348 char *type_str = #type"["__stringify(len)"]"; \ 349 BUILD_BUG_ON(len > MAX_FILTER_STR_VAL); \ 350 ret = trace_define_field(event_call, type_str, #item, \ 351 offsetof(typeof(field), item), \ 352 sizeof(field.item), \ 353 is_signed_type(type), FILTER_OTHER); \ 354 if (ret) \ 355 return ret; \ 356 } while (0); 357 358 #undef __dynamic_array 359 #define __dynamic_array(type, item, len) \ 360 ret = trace_define_field(event_call, "__data_loc " #type "[]", #item, \ 361 offsetof(typeof(field), __data_loc_##item), \ 362 sizeof(field.__data_loc_##item), \ 363 is_signed_type(type), FILTER_OTHER); 364 365 #undef __string 366 #define __string(item, src) __dynamic_array(char, item, -1) 367 368 #undef __bitmask 369 #define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1) 370 371 #undef DECLARE_EVENT_CLASS 372 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, func, print) \ 373 static int notrace __init \ 374 ftrace_define_fields_##call(struct ftrace_event_call *event_call) \ 375 { \ 376 struct ftrace_raw_##call field; \ 377 int ret; \ 378 \ 379 tstruct; \ 380 \ 381 return ret; \ 382 } 383 384 #undef DEFINE_EVENT 385 #define DEFINE_EVENT(template, name, proto, args) 386 387 #undef DEFINE_EVENT_PRINT 388 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ 389 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) 390 391 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) 392 393 /* 394 * remember the offset of each array from the beginning of the event. 395 */ 396 397 #undef __entry 398 #define __entry entry 399 400 #undef __field 401 #define __field(type, item) 402 403 #undef __field_ext 404 #define __field_ext(type, item, filter_type) 405 406 #undef __field_struct 407 #define __field_struct(type, item) 408 409 #undef __field_struct_ext 410 #define __field_struct_ext(type, item, filter_type) 411 412 #undef __array 413 #define __array(type, item, len) 414 415 #undef __dynamic_array 416 #define __dynamic_array(type, item, len) \ 417 __item_length = (len) * sizeof(type); \ 418 __data_offsets->item = __data_size + \ 419 offsetof(typeof(*entry), __data); \ 420 __data_offsets->item |= __item_length << 16; \ 421 __data_size += __item_length; 422 423 #undef __string 424 #define __string(item, src) __dynamic_array(char, item, \ 425 strlen((src) ? (const char *)(src) : "(null)") + 1) 426 427 /* 428 * __bitmask_size_in_bytes_raw is the number of bytes needed to hold 429 * num_possible_cpus(). 430 */ 431 #define __bitmask_size_in_bytes_raw(nr_bits) \ 432 (((nr_bits) + 7) / 8) 433 434 #define __bitmask_size_in_longs(nr_bits) \ 435 ((__bitmask_size_in_bytes_raw(nr_bits) + \ 436 ((BITS_PER_LONG / 8) - 1)) / (BITS_PER_LONG / 8)) 437 438 /* 439 * __bitmask_size_in_bytes is the number of bytes needed to hold 440 * num_possible_cpus() padded out to the nearest long. This is what 441 * is saved in the buffer, just to be consistent. 442 */ 443 #define __bitmask_size_in_bytes(nr_bits) \ 444 (__bitmask_size_in_longs(nr_bits) * (BITS_PER_LONG / 8)) 445 446 #undef __bitmask 447 #define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, \ 448 __bitmask_size_in_longs(nr_bits)) 449 450 #undef DECLARE_EVENT_CLASS 451 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \ 452 static inline notrace int ftrace_get_offsets_##call( \ 453 struct ftrace_data_offsets_##call *__data_offsets, proto) \ 454 { \ 455 int __data_size = 0; \ 456 int __maybe_unused __item_length; \ 457 struct ftrace_raw_##call __maybe_unused *entry; \ 458 \ 459 tstruct; \ 460 \ 461 return __data_size; \ 462 } 463 464 #undef DEFINE_EVENT 465 #define DEFINE_EVENT(template, name, proto, args) 466 467 #undef DEFINE_EVENT_PRINT 468 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ 469 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) 470 471 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) 472 473 /* 474 * Stage 4 of the trace events. 475 * 476 * Override the macros in <trace/trace_events.h> to include the following: 477 * 478 * For those macros defined with TRACE_EVENT: 479 * 480 * static struct ftrace_event_call event_<call>; 481 * 482 * static void ftrace_raw_event_<call>(void *__data, proto) 483 * { 484 * struct ftrace_event_file *ftrace_file = __data; 485 * struct ftrace_event_call *event_call = ftrace_file->event_call; 486 * struct ftrace_data_offsets_<call> __maybe_unused __data_offsets; 487 * unsigned long eflags = ftrace_file->flags; 488 * enum event_trigger_type __tt = ETT_NONE; 489 * struct ring_buffer_event *event; 490 * struct ftrace_raw_<call> *entry; <-- defined in stage 1 491 * struct ring_buffer *buffer; 492 * unsigned long irq_flags; 493 * int __data_size; 494 * int pc; 495 * 496 * if (!(eflags & FTRACE_EVENT_FL_TRIGGER_COND)) { 497 * if (eflags & FTRACE_EVENT_FL_TRIGGER_MODE) 498 * event_triggers_call(ftrace_file, NULL); 499 * if (eflags & FTRACE_EVENT_FL_SOFT_DISABLED) 500 * return; 501 * } 502 * 503 * local_save_flags(irq_flags); 504 * pc = preempt_count(); 505 * 506 * __data_size = ftrace_get_offsets_<call>(&__data_offsets, args); 507 * 508 * event = trace_event_buffer_lock_reserve(&buffer, ftrace_file, 509 * event_<call>->event.type, 510 * sizeof(*entry) + __data_size, 511 * irq_flags, pc); 512 * if (!event) 513 * return; 514 * entry = ring_buffer_event_data(event); 515 * 516 * { <assign>; } <-- Here we assign the entries by the __field and 517 * __array macros. 518 * 519 * if (eflags & FTRACE_EVENT_FL_TRIGGER_COND) 520 * __tt = event_triggers_call(ftrace_file, entry); 521 * 522 * if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, 523 * &ftrace_file->flags)) 524 * ring_buffer_discard_commit(buffer, event); 525 * else if (!filter_check_discard(ftrace_file, entry, buffer, event)) 526 * trace_buffer_unlock_commit(buffer, event, irq_flags, pc); 527 * 528 * if (__tt) 529 * event_triggers_post_call(ftrace_file, __tt); 530 * } 531 * 532 * static struct trace_event ftrace_event_type_<call> = { 533 * .trace = ftrace_raw_output_<call>, <-- stage 2 534 * }; 535 * 536 * static const char print_fmt_<call>[] = <TP_printk>; 537 * 538 * static struct ftrace_event_class __used event_class_<template> = { 539 * .system = "<system>", 540 * .define_fields = ftrace_define_fields_<call>, 541 * .fields = LIST_HEAD_INIT(event_class_##call.fields), 542 * .raw_init = trace_event_raw_init, 543 * .probe = ftrace_raw_event_##call, 544 * .reg = ftrace_event_reg, 545 * }; 546 * 547 * static struct ftrace_event_call event_<call> = { 548 * .class = event_class_<template>, 549 * { 550 * .tp = &__tracepoint_<call>, 551 * }, 552 * .event = &ftrace_event_type_<call>, 553 * .print_fmt = print_fmt_<call>, 554 * .flags = TRACE_EVENT_FL_TRACEPOINT, 555 * }; 556 * // its only safe to use pointers when doing linker tricks to 557 * // create an array. 558 * static struct ftrace_event_call __used 559 * __attribute__((section("_ftrace_events"))) *__event_<call> = &event_<call>; 560 * 561 */ 562 563 #ifdef CONFIG_PERF_EVENTS 564 565 #define _TRACE_PERF_PROTO(call, proto) \ 566 static notrace void \ 567 perf_trace_##call(void *__data, proto); 568 569 #define _TRACE_PERF_INIT(call) \ 570 .perf_probe = perf_trace_##call, 571 572 #else 573 #define _TRACE_PERF_PROTO(call, proto) 574 #define _TRACE_PERF_INIT(call) 575 #endif /* CONFIG_PERF_EVENTS */ 576 577 #undef __entry 578 #define __entry entry 579 580 #undef __field 581 #define __field(type, item) 582 583 #undef __field_struct 584 #define __field_struct(type, item) 585 586 #undef __array 587 #define __array(type, item, len) 588 589 #undef __dynamic_array 590 #define __dynamic_array(type, item, len) \ 591 __entry->__data_loc_##item = __data_offsets.item; 592 593 #undef __string 594 #define __string(item, src) __dynamic_array(char, item, -1) 595 596 #undef __assign_str 597 #define __assign_str(dst, src) \ 598 strcpy(__get_str(dst), (src) ? (const char *)(src) : "(null)"); 599 600 #undef __bitmask 601 #define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1) 602 603 #undef __get_bitmask 604 #define __get_bitmask(field) (char *)__get_dynamic_array(field) 605 606 #undef __assign_bitmask 607 #define __assign_bitmask(dst, src, nr_bits) \ 608 memcpy(__get_bitmask(dst), (src), __bitmask_size_in_bytes(nr_bits)) 609 610 #undef TP_fast_assign 611 #define TP_fast_assign(args...) args 612 613 #undef __perf_addr 614 #define __perf_addr(a) (a) 615 616 #undef __perf_count 617 #define __perf_count(c) (c) 618 619 #undef __perf_task 620 #define __perf_task(t) (t) 621 622 #undef DECLARE_EVENT_CLASS 623 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \ 624 \ 625 static notrace void \ 626 ftrace_raw_event_##call(void *__data, proto) \ 627 { \ 628 struct ftrace_event_file *ftrace_file = __data; \ 629 struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\ 630 struct ftrace_event_buffer fbuffer; \ 631 struct ftrace_raw_##call *entry; \ 632 int __data_size; \ 633 \ 634 if (ftrace_trigger_soft_disabled(ftrace_file)) \ 635 return; \ 636 \ 637 __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \ 638 \ 639 entry = ftrace_event_buffer_reserve(&fbuffer, ftrace_file, \ 640 sizeof(*entry) + __data_size); \ 641 \ 642 if (!entry) \ 643 return; \ 644 \ 645 tstruct \ 646 \ 647 { assign; } \ 648 \ 649 ftrace_event_buffer_commit(&fbuffer); \ 650 } 651 /* 652 * The ftrace_test_probe is compiled out, it is only here as a build time check 653 * to make sure that if the tracepoint handling changes, the ftrace probe will 654 * fail to compile unless it too is updated. 655 */ 656 657 #undef DEFINE_EVENT 658 #define DEFINE_EVENT(template, call, proto, args) \ 659 static inline void ftrace_test_probe_##call(void) \ 660 { \ 661 check_trace_callback_type_##call(ftrace_raw_event_##template); \ 662 } 663 664 #undef DEFINE_EVENT_PRINT 665 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) 666 667 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) 668 669 #undef __entry 670 #define __entry REC 671 672 #undef __print_flags 673 #undef __print_symbolic 674 #undef __print_hex 675 #undef __get_dynamic_array 676 #undef __get_dynamic_array_len 677 #undef __get_str 678 #undef __get_bitmask 679 680 #undef TP_printk 681 #define TP_printk(fmt, args...) "\"" fmt "\", " __stringify(args) 682 683 #undef DECLARE_EVENT_CLASS 684 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \ 685 _TRACE_PERF_PROTO(call, PARAMS(proto)); \ 686 static const char print_fmt_##call[] = print; \ 687 static struct ftrace_event_class __used __refdata event_class_##call = { \ 688 .system = __stringify(TRACE_SYSTEM), \ 689 .define_fields = ftrace_define_fields_##call, \ 690 .fields = LIST_HEAD_INIT(event_class_##call.fields),\ 691 .raw_init = trace_event_raw_init, \ 692 .probe = ftrace_raw_event_##call, \ 693 .reg = ftrace_event_reg, \ 694 _TRACE_PERF_INIT(call) \ 695 }; 696 697 #undef DEFINE_EVENT 698 #define DEFINE_EVENT(template, call, proto, args) \ 699 \ 700 static struct ftrace_event_call __used event_##call = { \ 701 .class = &event_class_##template, \ 702 { \ 703 .tp = &__tracepoint_##call, \ 704 }, \ 705 .event.funcs = &ftrace_event_type_funcs_##template, \ 706 .print_fmt = print_fmt_##template, \ 707 .flags = TRACE_EVENT_FL_TRACEPOINT, \ 708 }; \ 709 static struct ftrace_event_call __used \ 710 __attribute__((section("_ftrace_events"))) *__event_##call = &event_##call 711 712 #undef DEFINE_EVENT_PRINT 713 #define DEFINE_EVENT_PRINT(template, call, proto, args, print) \ 714 \ 715 static const char print_fmt_##call[] = print; \ 716 \ 717 static struct ftrace_event_call __used event_##call = { \ 718 .class = &event_class_##template, \ 719 { \ 720 .tp = &__tracepoint_##call, \ 721 }, \ 722 .event.funcs = &ftrace_event_type_funcs_##call, \ 723 .print_fmt = print_fmt_##call, \ 724 .flags = TRACE_EVENT_FL_TRACEPOINT, \ 725 }; \ 726 static struct ftrace_event_call __used \ 727 __attribute__((section("_ftrace_events"))) *__event_##call = &event_##call 728 729 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) 730 731 732 #ifdef CONFIG_PERF_EVENTS 733 734 #undef __entry 735 #define __entry entry 736 737 #undef __get_dynamic_array 738 #define __get_dynamic_array(field) \ 739 ((void *)__entry + (__entry->__data_loc_##field & 0xffff)) 740 741 #undef __get_dynamic_array_len 742 #define __get_dynamic_array_len(field) \ 743 ((__entry->__data_loc_##field >> 16) & 0xffff) 744 745 #undef __get_str 746 #define __get_str(field) (char *)__get_dynamic_array(field) 747 748 #undef __get_bitmask 749 #define __get_bitmask(field) (char *)__get_dynamic_array(field) 750 751 #undef __perf_addr 752 #define __perf_addr(a) (__addr = (a)) 753 754 #undef __perf_count 755 #define __perf_count(c) (__count = (c)) 756 757 #undef __perf_task 758 #define __perf_task(t) (__task = (t)) 759 760 #undef DECLARE_EVENT_CLASS 761 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \ 762 static notrace void \ 763 perf_trace_##call(void *__data, proto) \ 764 { \ 765 struct ftrace_event_call *event_call = __data; \ 766 struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\ 767 struct ftrace_raw_##call *entry; \ 768 struct pt_regs *__regs; \ 769 u64 __addr = 0, __count = 1; \ 770 struct task_struct *__task = NULL; \ 771 struct hlist_head *head; \ 772 int __entry_size; \ 773 int __data_size; \ 774 int rctx; \ 775 \ 776 __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \ 777 \ 778 head = this_cpu_ptr(event_call->perf_events); \ 779 if (__builtin_constant_p(!__task) && !__task && \ 780 hlist_empty(head)) \ 781 return; \ 782 \ 783 __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\ 784 sizeof(u64)); \ 785 __entry_size -= sizeof(u32); \ 786 \ 787 entry = perf_trace_buf_prepare(__entry_size, \ 788 event_call->event.type, &__regs, &rctx); \ 789 if (!entry) \ 790 return; \ 791 \ 792 perf_fetch_caller_regs(__regs); \ 793 \ 794 tstruct \ 795 \ 796 { assign; } \ 797 \ 798 perf_trace_buf_submit(entry, __entry_size, rctx, __addr, \ 799 __count, __regs, head, __task); \ 800 } 801 802 /* 803 * This part is compiled out, it is only here as a build time check 804 * to make sure that if the tracepoint handling changes, the 805 * perf probe will fail to compile unless it too is updated. 806 */ 807 #undef DEFINE_EVENT 808 #define DEFINE_EVENT(template, call, proto, args) \ 809 static inline void perf_test_probe_##call(void) \ 810 { \ 811 check_trace_callback_type_##call(perf_trace_##template); \ 812 } 813 814 815 #undef DEFINE_EVENT_PRINT 816 #define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ 817 DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) 818 819 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) 820 #endif /* CONFIG_PERF_EVENTS */ 821 822