From: Linus Torvalds Date: Wed, 23 Mar 2022 18:40:25 +0000 (-0700) Subject: Merge tag 'trace-v5.18' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt... X-Git-Tag: howlett/maple/20220722_2~964 X-Git-Url: https://www.infradead.org/git/?a=commitdiff_plain;h=1bc191051dca28fa6d20fd1dc34a1903e7d4fb62;p=users%2Fjedix%2Flinux-maple.git Merge tag 'trace-v5.18' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace Pull tracing updates from Steven Rostedt: - New user_events interface. User space can register an event with the kernel describing the format of the event. Then it will receive a byte in a page mapping that it can check against. A privileged task can then enable that event like any other event, which will change the mapped byte to true, telling the user space application to start writing the event to the tracing buffer. - Add new "ftrace_boot_snapshot" kernel command line parameter. When set, the tracing buffer will be saved in the snapshot buffer at boot up when the kernel hands things over to user space. This will keep the traces that happened at boot up available even if user space boot up has tracing as well. - Have TRACE_EVENT_ENUM() also update trace event field type descriptions. Thus if a static array defines its size with an enum, the user space trace event parsers can still know how to parse that array. - Add new TRACE_CUSTOM_EVENT() macro. This acts the same as the TRACE_EVENT() macro, but will attach to an existing tracepoint. This will make one tracepoint be able to trace different content and not be stuck at only what the original TRACE_EVENT() macro exports. - Fixes to tracing error logging. - Better saving of cmdlines to PIDs when tracing (use the wakeup events for mapping). * tag 'trace-v5.18' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace: (30 commits) tracing: Have type enum modifications copy the strings user_events: Add trace event call as root for low permission cases tracing/user_events: Use alloc_pages instead of kzalloc() for register pages tracing: Add snapshot at end of kernel boot up tracing: Have TRACE_DEFINE_ENUM affect trace event types as well tracing: Fix strncpy warning in trace_events_synth.c user_events: Prevent dyn_event delete racing with ioctl add/delete tracing: Add TRACE_CUSTOM_EVENT() macro tracing: Move the defines to create TRACE_EVENTS into their own files tracing: Add sample code for custom trace events tracing: Allow custom events to be added to the tracefs directory tracing: Fix last_cmd_set() string management in histogram code user_events: Fix potential uninitialized pointer while parsing field tracing: Fix allocation of last_cmd in last_cmd_set() user_events: Add documentation file user_events: Add sample code for typical usage user_events: Add self-test for validator boundaries user_events: Add self-test for perf_event integration user_events: Add self-test for dynamic_events integration user_events: Add self-test for ftrace integration ... --- 1bc191051dca28fa6d20fd1dc34a1903e7d4fb62 diff --cc include/trace/stages/stage1_defines.h index 000000000000,8ab88c766d2b..a16783419687 mode 000000,100644..100644 --- a/include/trace/stages/stage1_defines.h +++ b/include/trace/stages/stage1_defines.h @@@ -1,0 -1,45 +1,51 @@@ + /* SPDX-License-Identifier: GPL-2.0 */ + + /* Stage 1 definitions for creating trace events */ + + #undef __field + #define __field(type, item) type item; + + #undef __field_ext + #define __field_ext(type, item, filter_type) type item; + + #undef __field_struct + #define __field_struct(type, item) type item; + + #undef __field_struct_ext + #define __field_struct_ext(type, item, filter_type) type item; + + #undef __array + #define __array(type, item, len) type item[len]; + + #undef __dynamic_array + #define __dynamic_array(type, item, len) u32 __data_loc_##item; + + #undef __string + #define __string(item, src) __dynamic_array(char, item, -1) + + #undef __string_len + #define __string_len(item, src, len) __dynamic_array(char, item, -1) + + #undef __bitmask + #define __bitmask(item, nr_bits) __dynamic_array(char, item, -1) + ++#undef __sockaddr ++#define __sockaddr(field, len) __dynamic_array(u8, field, len) ++ + #undef __rel_dynamic_array + #define __rel_dynamic_array(type, item, len) u32 __rel_loc_##item; + + #undef __rel_string + #define __rel_string(item, src) __rel_dynamic_array(char, item, -1) + + #undef __rel_string_len + #define __rel_string_len(item, src, len) __rel_dynamic_array(char, item, -1) + + #undef __rel_bitmask + #define __rel_bitmask(item, nr_bits) __rel_dynamic_array(char, item, -1) + ++#undef __rel_sockaddr ++#define __rel_sockaddr(field, len) __rel_dynamic_array(u8, field, len) ++ + #undef TP_STRUCT__entry + #define TP_STRUCT__entry(args...) args diff --cc include/trace/stages/stage2_defines.h index 000000000000,9f2341df40da..42fd1e8813ec mode 000000,100644..100644 --- a/include/trace/stages/stage2_defines.h +++ b/include/trace/stages/stage2_defines.h @@@ -1,0 -1,48 +1,54 @@@ + /* SPDX-License-Identifier: GPL-2.0 */ + + /* Stage 2 definitions for creating trace events */ + + #undef TRACE_DEFINE_ENUM + #define TRACE_DEFINE_ENUM(a) + + #undef TRACE_DEFINE_SIZEOF + #define TRACE_DEFINE_SIZEOF(a) + + #undef __field + #define __field(type, item) + + #undef __field_ext + #define __field_ext(type, item, filter_type) + + #undef __field_struct + #define __field_struct(type, item) + + #undef __field_struct_ext + #define __field_struct_ext(type, item, filter_type) + + #undef __array + #define __array(type, item, len) + + #undef __dynamic_array + #define __dynamic_array(type, item, len) u32 item; + + #undef __string + #define __string(item, src) __dynamic_array(char, item, -1) + ++#undef __string_len ++#define __string_len(item, src, len) __dynamic_array(char, item, -1) ++ + #undef __bitmask + #define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1) + -#undef __string_len -#define __string_len(item, src, len) __dynamic_array(char, item, -1) ++#undef __sockaddr ++#define __sockaddr(field, len) __dynamic_array(u8, field, len) + + #undef __rel_dynamic_array + #define __rel_dynamic_array(type, item, len) u32 item; + + #undef __rel_string + #define __rel_string(item, src) __rel_dynamic_array(char, item, -1) + + #undef __rel_string_len + #define __rel_string_len(item, src, len) __rel_dynamic_array(char, item, -1) + + #undef __rel_bitmask + #define __rel_bitmask(item, nr_bits) __rel_dynamic_array(unsigned long, item, -1) ++ ++#undef __rel_sockaddr ++#define __rel_sockaddr(field, len) __rel_dynamic_array(u8, field, len) diff --cc include/trace/stages/stage3_defines.h index 000000000000,0bc131993b7a..e3b183e9d18e mode 000000,100644..100644 --- a/include/trace/stages/stage3_defines.h +++ b/include/trace/stages/stage3_defines.h @@@ -1,0 -1,129 +1,135 @@@ + /* SPDX-License-Identifier: GPL-2.0 */ + + /* Stage 3 definitions for creating trace events */ + + #undef __entry + #define __entry field + + #undef TP_printk + #define TP_printk(fmt, args...) fmt "\n", args + + #undef __get_dynamic_array + #define __get_dynamic_array(field) \ + ((void *)__entry + (__entry->__data_loc_##field & 0xffff)) + + #undef __get_dynamic_array_len + #define __get_dynamic_array_len(field) \ + ((__entry->__data_loc_##field >> 16) & 0xffff) + + #undef __get_str + #define __get_str(field) ((char *)__get_dynamic_array(field)) + + #undef __get_rel_dynamic_array + #define __get_rel_dynamic_array(field) \ + ((void *)__entry + \ + offsetof(typeof(*__entry), __rel_loc_##field) + \ + sizeof(__entry->__rel_loc_##field) + \ + (__entry->__rel_loc_##field & 0xffff)) + + #undef __get_rel_dynamic_array_len + #define __get_rel_dynamic_array_len(field) \ + ((__entry->__rel_loc_##field >> 16) & 0xffff) + + #undef __get_rel_str + #define __get_rel_str(field) ((char *)__get_rel_dynamic_array(field)) + + #undef __get_bitmask + #define __get_bitmask(field) \ + ({ \ + void *__bitmask = __get_dynamic_array(field); \ + unsigned int __bitmask_size; \ + __bitmask_size = __get_dynamic_array_len(field); \ + trace_print_bitmask_seq(p, __bitmask, __bitmask_size); \ + }) + + #undef __get_rel_bitmask + #define __get_rel_bitmask(field) \ + ({ \ + void *__bitmask = __get_rel_dynamic_array(field); \ + unsigned int __bitmask_size; \ + __bitmask_size = __get_rel_dynamic_array_len(field); \ + trace_print_bitmask_seq(p, __bitmask, __bitmask_size); \ + }) + ++#undef __get_sockaddr ++#define __get_sockaddr(field) ((struct sockaddr *)__get_dynamic_array(field)) ++ ++#undef __get_rel_sockaddr ++#define __get_rel_sockaddr(field) ((struct sockaddr *)__get_rel_dynamic_array(field)) ++ + #undef __print_flags + #define __print_flags(flag, delim, flag_array...) \ + ({ \ + static const struct trace_print_flags __flags[] = \ + { flag_array, { -1, NULL }}; \ + trace_print_flags_seq(p, delim, flag, __flags); \ + }) + + #undef __print_symbolic + #define __print_symbolic(value, symbol_array...) \ + ({ \ + static const struct trace_print_flags symbols[] = \ + { symbol_array, { -1, NULL }}; \ + trace_print_symbols_seq(p, value, symbols); \ + }) + + #undef __print_flags_u64 + #undef __print_symbolic_u64 + #if BITS_PER_LONG == 32 + #define __print_flags_u64(flag, delim, flag_array...) \ + ({ \ + static const struct trace_print_flags_u64 __flags[] = \ + { flag_array, { -1, NULL } }; \ + trace_print_flags_seq_u64(p, delim, flag, __flags); \ + }) + + #define __print_symbolic_u64(value, symbol_array...) \ + ({ \ + static const struct trace_print_flags_u64 symbols[] = \ + { symbol_array, { -1, NULL } }; \ + trace_print_symbols_seq_u64(p, value, symbols); \ + }) + #else + #define __print_flags_u64(flag, delim, flag_array...) \ + __print_flags(flag, delim, flag_array) + + #define __print_symbolic_u64(value, symbol_array...) \ + __print_symbolic(value, symbol_array) + #endif + + #undef __print_hex + #define __print_hex(buf, buf_len) \ + trace_print_hex_seq(p, buf, buf_len, false) + + #undef __print_hex_str + #define __print_hex_str(buf, buf_len) \ + trace_print_hex_seq(p, buf, buf_len, true) + + #undef __print_array + #define __print_array(array, count, el_size) \ + ({ \ + BUILD_BUG_ON(el_size != 1 && el_size != 2 && \ + el_size != 4 && el_size != 8); \ + trace_print_array_seq(p, array, count, el_size); \ + }) + + #undef __print_hex_dump + #define __print_hex_dump(prefix_str, prefix_type, \ + rowsize, groupsize, buf, len, ascii) \ + trace_print_hex_dump_seq(p, prefix_str, prefix_type, \ + rowsize, groupsize, buf, len, ascii) + + #undef __print_ns_to_secs + #define __print_ns_to_secs(value) \ + ({ \ + u64 ____val = (u64)(value); \ + do_div(____val, NSEC_PER_SEC); \ + ____val; \ + }) + + #undef __print_ns_without_secs + #define __print_ns_without_secs(value) \ + ({ \ + u64 ____val = (u64)(value); \ + (u32) do_div(____val, NSEC_PER_SEC); \ + }) diff --cc include/trace/stages/stage4_defines.h index 000000000000,780a10fa5279..e80cdc397a43 mode 000000,100644..100644 --- a/include/trace/stages/stage4_defines.h +++ b/include/trace/stages/stage4_defines.h @@@ -1,0 -1,57 +1,63 @@@ + /* SPDX-License-Identifier: GPL-2.0 */ + + /* Stage 4 definitions for creating trace events */ + + #undef __field_ext + #define __field_ext(_type, _item, _filter_type) { \ + .type = #_type, .name = #_item, \ + .size = sizeof(_type), .align = __alignof__(_type), \ + .is_signed = is_signed_type(_type), .filter_type = _filter_type }, + + #undef __field_struct_ext + #define __field_struct_ext(_type, _item, _filter_type) { \ + .type = #_type, .name = #_item, \ + .size = sizeof(_type), .align = __alignof__(_type), \ + 0, .filter_type = _filter_type }, + + #undef __field + #define __field(type, item) __field_ext(type, item, FILTER_OTHER) + + #undef __field_struct + #define __field_struct(type, item) __field_struct_ext(type, item, FILTER_OTHER) + + #undef __array + #define __array(_type, _item, _len) { \ + .type = #_type"["__stringify(_len)"]", .name = #_item, \ + .size = sizeof(_type[_len]), .align = __alignof__(_type), \ + .is_signed = is_signed_type(_type), .filter_type = FILTER_OTHER }, + + #undef __dynamic_array + #define __dynamic_array(_type, _item, _len) { \ + .type = "__data_loc " #_type "[]", .name = #_item, \ + .size = 4, .align = 4, \ + .is_signed = is_signed_type(_type), .filter_type = FILTER_OTHER }, + + #undef __string + #define __string(item, src) __dynamic_array(char, item, -1) + + #undef __string_len + #define __string_len(item, src, len) __dynamic_array(char, item, -1) + + #undef __bitmask + #define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1) + ++#undef __sockaddr ++#define __sockaddr(field, len) __dynamic_array(u8, field, len) ++ + #undef __rel_dynamic_array + #define __rel_dynamic_array(_type, _item, _len) { \ + .type = "__rel_loc " #_type "[]", .name = #_item, \ + .size = 4, .align = 4, \ + .is_signed = is_signed_type(_type), .filter_type = FILTER_OTHER }, + + #undef __rel_string + #define __rel_string(item, src) __rel_dynamic_array(char, item, -1) + + #undef __rel_string_len + #define __rel_string_len(item, src, len) __rel_dynamic_array(char, item, -1) + + #undef __rel_bitmask + #define __rel_bitmask(item, nr_bits) __rel_dynamic_array(unsigned long, item, -1) ++ ++#undef __rel_sockaddr ++#define __rel_sockaddr(field, len) __rel_dynamic_array(u8, field, len) diff --cc include/trace/stages/stage5_defines.h index 000000000000,fb15394aae31..7ee5931300e6 mode 000000,100644..100644 --- a/include/trace/stages/stage5_defines.h +++ b/include/trace/stages/stage5_defines.h @@@ -1,0 -1,83 +1,89 @@@ + /* SPDX-License-Identifier: GPL-2.0 */ + + /* Stage 5 definitions for creating trace events */ + + /* + * remember the offset of each array from the beginning of the event. + */ + + #undef __entry + #define __entry entry + + #undef __field + #define __field(type, item) + + #undef __field_ext + #define __field_ext(type, item, filter_type) + + #undef __field_struct + #define __field_struct(type, item) + + #undef __field_struct_ext + #define __field_struct_ext(type, item, filter_type) + + #undef __array + #define __array(type, item, len) + + #undef __dynamic_array + #define __dynamic_array(type, item, len) \ + __item_length = (len) * sizeof(type); \ + __data_offsets->item = __data_size + \ + offsetof(typeof(*entry), __data); \ + __data_offsets->item |= __item_length << 16; \ + __data_size += __item_length; + + #undef __string + #define __string(item, src) __dynamic_array(char, item, \ + strlen((src) ? (const char *)(src) : "(null)") + 1) + + #undef __string_len + #define __string_len(item, src, len) __dynamic_array(char, item, (len) + 1) + + #undef __rel_dynamic_array + #define __rel_dynamic_array(type, item, len) \ + __item_length = (len) * sizeof(type); \ + __data_offsets->item = __data_size + \ + offsetof(typeof(*entry), __data) - \ + offsetof(typeof(*entry), __rel_loc_##item) - \ + sizeof(u32); \ + __data_offsets->item |= __item_length << 16; \ + __data_size += __item_length; + + #undef __rel_string + #define __rel_string(item, src) __rel_dynamic_array(char, item, \ + strlen((src) ? (const char *)(src) : "(null)") + 1) + + #undef __rel_string_len + #define __rel_string_len(item, src, len) __rel_dynamic_array(char, item, (len) + 1) + /* + * __bitmask_size_in_bytes_raw is the number of bytes needed to hold + * num_possible_cpus(). + */ + #define __bitmask_size_in_bytes_raw(nr_bits) \ + (((nr_bits) + 7) / 8) + + #define __bitmask_size_in_longs(nr_bits) \ + ((__bitmask_size_in_bytes_raw(nr_bits) + \ + ((BITS_PER_LONG / 8) - 1)) / (BITS_PER_LONG / 8)) + + /* + * __bitmask_size_in_bytes is the number of bytes needed to hold + * num_possible_cpus() padded out to the nearest long. This is what + * is saved in the buffer, just to be consistent. + */ + #define __bitmask_size_in_bytes(nr_bits) \ + (__bitmask_size_in_longs(nr_bits) * (BITS_PER_LONG / 8)) + + #undef __bitmask + #define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, \ + __bitmask_size_in_longs(nr_bits)) + + #undef __rel_bitmask + #define __rel_bitmask(item, nr_bits) __rel_dynamic_array(unsigned long, item, \ + __bitmask_size_in_longs(nr_bits)) ++ ++#undef __sockaddr ++#define __sockaddr(field, len) __dynamic_array(u8, field, len) ++ ++#undef __rel_sockaddr ++#define __rel_sockaddr(field, len) __rel_dynamic_array(u8, field, len) diff --cc include/trace/stages/stage6_defines.h index 000000000000,b3a1f26026be..e1724f73594b mode 000000,100644..100644 --- a/include/trace/stages/stage6_defines.h +++ b/include/trace/stages/stage6_defines.h @@@ -1,0 -1,86 +1,106 @@@ + /* SPDX-License-Identifier: GPL-2.0 */ + + /* Stage 6 definitions for creating trace events */ + + #undef __entry + #define __entry entry + + #undef __field + #define __field(type, item) + + #undef __field_struct + #define __field_struct(type, item) + + #undef __array + #define __array(type, item, len) + + #undef __dynamic_array + #define __dynamic_array(type, item, len) \ + __entry->__data_loc_##item = __data_offsets.item; + + #undef __string + #define __string(item, src) __dynamic_array(char, item, -1) + + #undef __string_len + #define __string_len(item, src, len) __dynamic_array(char, item, -1) + + #undef __assign_str + #define __assign_str(dst, src) \ + strcpy(__get_str(dst), (src) ? (const char *)(src) : "(null)"); + + #undef __assign_str_len + #define __assign_str_len(dst, src, len) \ + do { \ + memcpy(__get_str(dst), (src), (len)); \ + __get_str(dst)[len] = '\0'; \ + } while(0) + + #undef __bitmask + #define __bitmask(item, nr_bits) __dynamic_array(unsigned long, item, -1) + + #undef __get_bitmask + #define __get_bitmask(field) (char *)__get_dynamic_array(field) + + #undef __assign_bitmask + #define __assign_bitmask(dst, src, nr_bits) \ + memcpy(__get_bitmask(dst), (src), __bitmask_size_in_bytes(nr_bits)) + ++#undef __sockaddr ++#define __sockaddr(field, len) __dynamic_array(u8, field, len) ++ ++#undef __get_sockaddr ++#define __get_sockaddr(field) ((struct sockaddr *)__get_dynamic_array(field)) ++ ++#undef __assign_sockaddr ++#define __assign_sockaddr(dest, src, len) \ ++ memcpy(__get_dynamic_array(dest), src, len) ++ + #undef __rel_dynamic_array + #define __rel_dynamic_array(type, item, len) \ + __entry->__rel_loc_##item = __data_offsets.item; + + #undef __rel_string + #define __rel_string(item, src) __rel_dynamic_array(char, item, -1) + + #undef __rel_string_len + #define __rel_string_len(item, src, len) __rel_dynamic_array(char, item, -1) + + #undef __assign_rel_str + #define __assign_rel_str(dst, src) \ + strcpy(__get_rel_str(dst), (src) ? (const char *)(src) : "(null)"); + + #undef __assign_rel_str_len + #define __assign_rel_str_len(dst, src, len) \ + do { \ + memcpy(__get_rel_str(dst), (src), (len)); \ + __get_rel_str(dst)[len] = '\0'; \ + } while (0) + + #undef __rel_bitmask + #define __rel_bitmask(item, nr_bits) __rel_dynamic_array(unsigned long, item, -1) + + #undef __get_rel_bitmask + #define __get_rel_bitmask(field) (char *)__get_rel_dynamic_array(field) + + #undef __assign_rel_bitmask + #define __assign_rel_bitmask(dst, src, nr_bits) \ + memcpy(__get_rel_bitmask(dst), (src), __bitmask_size_in_bytes(nr_bits)) + ++#undef __rel_sockaddr ++#define __rel_sockaddr(field, len) __rel_dynamic_array(u8, field, len) ++ ++#undef __get_rel_sockaddr ++#define __get_rel_sockaddr(field) ((struct sockaddr *)__get_rel_dynamic_array(field)) ++ ++#undef __assign_rel_sockaddr ++#define __assign_rel_sockaddr(dest, src, len) \ ++ memcpy(__get_rel_dynamic_array(dest), src, len) ++ + #undef TP_fast_assign + #define TP_fast_assign(args...) args + + #undef __perf_count + #define __perf_count(c) (c) + + #undef __perf_task + #define __perf_task(t) (t) diff --cc include/trace/stages/stage7_defines.h index 000000000000,d65445328f18..8a7ec24c246d mode 000000,100644..100644 --- a/include/trace/stages/stage7_defines.h +++ b/include/trace/stages/stage7_defines.h @@@ -1,0 -1,34 +1,36 @@@ + /* SPDX-License-Identifier: GPL-2.0 */ + + /* Stage 7 definitions for creating trace events */ + + #undef __entry + #define __entry REC + + #undef __print_flags + #undef __print_symbolic + #undef __print_hex + #undef __print_hex_str + #undef __get_dynamic_array + #undef __get_dynamic_array_len + #undef __get_str + #undef __get_bitmask ++#undef __get_sockaddr + #undef __get_rel_dynamic_array + #undef __get_rel_dynamic_array_len + #undef __get_rel_str + #undef __get_rel_bitmask ++#undef __get_rel_sockaddr + #undef __print_array + #undef __print_hex_dump + + /* + * The below is not executed in the kernel. It is only what is + * displayed in the print format for userspace to parse. + */ + #undef __print_ns_to_secs + #define __print_ns_to_secs(val) (val) / 1000000000UL + + #undef __print_ns_without_secs + #define __print_ns_without_secs(val) (val) % 1000000000UL + + #undef TP_printk + #define TP_printk(fmt, args...) "\"" fmt "\", " __stringify(args) diff --cc samples/trace_events/trace_custom_sched.h index 000000000000,a3d14de6a2e5..9fdd8e7c2a45 mode 000000,100644..100644 --- a/samples/trace_events/trace_custom_sched.h +++ b/samples/trace_events/trace_custom_sched.h @@@ -1,0 -1,95 +1,96 @@@ + /* SPDX-License-Identifier: GPL-2.0 */ + + /* + * Like the headers that use TRACE_EVENT(), the TRACE_CUSTOM_EVENT() + * needs a header that allows for multiple inclusions. + * + * Test for a unique name (here we have _TRACE_CUSTOM_SCHED_H), + * also allowing to continue if TRACE_CUSTOM_MULTI_READ is defined. + */ + #if !defined(_TRACE_CUSTOM_SCHED_H) || defined(TRACE_CUSTOM_MULTI_READ) + #define _TRACE_CUSTOM_SCHED_H + + /* Include linux/trace_events.h for initial defines of TRACE_CUSTOM_EVENT() */ + #include + + /* + * TRACE_CUSTOM_EVENT() is just like TRACE_EVENT(). The first parameter + * is the event name of an existing event where the TRACE_EVENT has been included + * in the C file before including this file. + */ + TRACE_CUSTOM_EVENT(sched_switch, + + /* + * The TP_PROTO() and TP_ARGS must match the trace event + * that the custom event is using. + */ + TP_PROTO(bool preempt, ++ unsigned int prev_state, + struct task_struct *prev, + struct task_struct *next), + - TP_ARGS(preempt, prev, next), ++ TP_ARGS(preempt, prev_state, prev, next), + + /* + * The next fields are where the customization happens. + * The TP_STRUCT__entry() defines what will be recorded + * in the ring buffer when the custom event triggers. + * + * The rest is just like the TRACE_EVENT() macro except that + * it uses the custom entry. + */ + TP_STRUCT__entry( + __field( unsigned short, prev_prio ) + __field( unsigned short, next_prio ) + __field( pid_t, next_pid ) + ), + + TP_fast_assign( + __entry->prev_prio = prev->prio; + __entry->next_pid = next->pid; + __entry->next_prio = next->prio; + ), + + TP_printk("prev_prio=%d next_pid=%d next_prio=%d", + __entry->prev_prio, __entry->next_pid, __entry->next_prio) + ) + + + TRACE_CUSTOM_EVENT(sched_waking, + + TP_PROTO(struct task_struct *p), + + TP_ARGS(p), + + TP_STRUCT__entry( + __field( pid_t, pid ) + __field( unsigned short, prio ) + ), + + TP_fast_assign( + __entry->pid = p->pid; + __entry->prio = p->prio; + ), + + TP_printk("pid=%d prio=%d", __entry->pid, __entry->prio) + ) + #endif + /* + * Just like the headers that create TRACE_EVENTs, the below must + * be outside the protection of the above #if block. + */ + + /* + * It is required that the Makefile includes: + * CFLAGS_.o := -I$(src) + */ + #undef TRACE_INCLUDE_PATH + #undef TRACE_INCLUDE_FILE + #define TRACE_INCLUDE_PATH . + + /* + * It is requred that the TRACE_INCLUDE_FILE be the same + * as this file without the ".h". + */ + #define TRACE_INCLUDE_FILE trace_custom_sched + #include