X-Git-Url: https://git.liburcu.org/?a=blobdiff_plain;f=probes%2Flttng-events.h;h=16e268044aefda3a77534605f6b67198ecc56474;hb=17baffe29814f2508556e498ab8c41a192e76b67;hp=b36e44f997cbb7c6576691ff317677d68fa1f3e5;hpb=85a8074292c4b3779437df0d7c737f3dba00ce58;p=lttng-modules.git diff --git a/probes/lttng-events.h b/probes/lttng-events.h index b36e44f9..16e26804 100644 --- a/probes/lttng-events.h +++ b/probes/lttng-events.h @@ -1,21 +1,20 @@ -#include -#include +/* + * lttng-events.h + * + * Copyright (C) 2009 Steven Rostedt + * Copyright (C) 2010-2011 Mathieu Desnoyers + * + * Dual LGPL v2.1/GPL v2 license. + */ + #include -#include +#include "lttng.h" +#include "lttng-types.h" +#include "../wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */ +#include "../wrapper/ringbuffer/frontend_types.h" #include "../ltt-events.h" #include "../ltt-tracer-core.h" -struct lttng_event_field { - const char *name; - const struct lttng_type type; -}; - -struct lttng_event_desc { - const struct lttng_event_field *fields; - const char *name; - unsigned int nr_fields; -}; - /* * Macro declarations used for all stages. */ @@ -54,6 +53,28 @@ struct lttng_event_desc { /* * Stage 1 of the trace events. * + * Create dummy trace calls for each events, verifying that the LTTng module + * TRACE_EVENT headers match the kernel arguments. Will be optimized out by the + * compiler. + */ + +#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */ + +#undef TP_PROTO +#define TP_PROTO(args...) args + +#undef TP_ARGS +#define TP_ARGS(args...) args + +#undef DEFINE_EVENT +#define DEFINE_EVENT(_template, _name, _proto, _args) \ +void trace_##_name(_proto); + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + +/* + * Stage 2 of the trace events. + * * Create event field type metadata section. * Each event produce an array of fields. */ @@ -64,43 +85,75 @@ struct lttng_event_desc { #undef __field #define __field(_type, _item) \ - { .name = #_item, .type = { .atype = atype_integer, .name = #_type} }, + { \ + .name = #_item, \ + .type = __type_integer(_type, __BYTE_ORDER, 10, none),\ + }, #undef __field_ext #define __field_ext(_type, _item, _filter_type) __field(_type, _item) -#undef __array -#define __array(_type, _item, _length) \ +#undef __field_network +#define __field_network(_type, _item) \ { \ - .name = #_item, \ - .type = { \ + .name = #_item, \ + .type = __type_integer(_type, __BIG_ENDIAN, 10, none),\ + }, + +#undef __array_enc +#define __array_enc(_type, _item, _length, _encoding) \ + { \ + .name = #_item, \ + .type = \ + { \ .atype = atype_array, \ - .name = NULL, \ - .u.array.elem_type = #_type, \ - .u.array.length = _length, \ + .u.array = \ + { \ + .length = _length, \ + .elem_type = __type_integer(_type, __BYTE_ORDER, 10, _encoding), \ + }, \ }, \ }, -#undef __dynamic_array -#define __dynamic_array(_type, _item, _length) \ +#undef __array +#define __array(_type, _item, _length) \ + __array_enc(_type, _item, _length, none) + +#undef __array_text +#define __array_text(_type, _item, _length) \ + __array_enc(_type, _item, _length, UTF8) + +#undef __dynamic_array_enc +#define __dynamic_array_enc(_type, _item, _length, _encoding) \ { \ - .name = #_item, \ - .type = { \ + .name = #_item, \ + .type = \ + { \ .atype = atype_sequence, \ - .name = NULL, \ - .u.sequence.elem_type = #_type, \ - .u.sequence.length_type = "u32", \ + .u.sequence = \ + { \ + .length_type = __type_integer(u32, __BYTE_ORDER, 10, none), \ + .elem_type = __type_integer(_type, __BYTE_ORDER, 10, _encoding), \ + }, \ }, \ }, +#undef __dynamic_array +#define __dynamic_array(_type, _item, _length) \ + __dynamic_array_enc(_type, _item, _length, none) + +#undef __dynamic_array_text +#define __dynamic_array_text(_type, _item, _length) \ + __dynamic_array_enc(_type, _item, _length, UTF8) + #undef __string #define __string(_item, _src) \ { \ - .name = #_item, \ - .type = { \ + .name = #_item, \ + .type = \ + { \ .atype = atype_string, \ - .name = NULL, \ - .u.string.encoding = lttng_encode_UTF8, \ + .u.basic.string.encoding = lttng_encode_UTF8, \ }, \ }, @@ -115,8 +168,27 @@ struct lttng_event_desc { #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) +#undef __type_integer + /* - * Stage 2 of the trace events. + * Stage 3 of the trace events. + * + * Create probe callback prototypes. + */ + +#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */ + +#undef TP_PROTO +#define TP_PROTO(args...) args + +#undef DECLARE_EVENT_CLASS +#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \ +static void __event_probe__##_name(void *__data, _proto); + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + +/* + * Stage 4 of the trace events. * * Create an array of events. */ @@ -130,7 +202,9 @@ struct lttng_event_desc { { \ .fields = __event_fields___##_template, \ .name = #_name, \ + .probe_callback = (void *) &__event_probe__##_template,\ .nr_fields = ARRAY_SIZE(__event_fields___##_template), \ + .owner = THIS_MODULE, \ }, #define TP_ID1(_token, _system) _token##_system @@ -143,131 +217,27 @@ static const struct lttng_event_desc TP_ID(__event_desc___, TRACE_SYSTEM)[] = { #undef TP_ID1 #undef TP_ID + /* - * Stage 3 of the trace events. + * Stage 5 of the trace events. * - * Create seq file metadata output. + * Create a toplevel descriptor for the whole probe. */ #define TP_ID1(_token, _system) _token##_system #define TP_ID(_token, _system) TP_ID1(_token, _system) -#define module_init_eval1(_token, _system) module_init(_token##_system) -#define module_init_eval(_token, _system) module_init_eval1(_token, _system) -#define module_exit_eval1(_token, _system) module_exit(_token##_system) -#define module_exit_eval(_token, _system) module_exit_eval1(_token, _system) - -static void *TP_ID(__lttng_seq_start__, TRACE_SYSTEM)(struct seq_file *m, - loff_t *pos) -{ - const struct lttng_event_desc *desc = - &TP_ID(__event_desc___, TRACE_SYSTEM)[*pos]; - - if (desc > &TP_ID(__event_desc___, TRACE_SYSTEM) - [ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)) - 1]) - return NULL; - return (void *) desc; -} - -static void *TP_ID(__lttng_seq_next__, TRACE_SYSTEM)(struct seq_file *m, - void *p, loff_t *ppos) -{ - const struct lttng_event_desc *desc = - &TP_ID(__event_desc___, TRACE_SYSTEM)[++(*ppos)]; - - if (desc > &TP_ID(__event_desc___, TRACE_SYSTEM) - [ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)) - 1]) - return NULL; - return (void *) desc; -} - -static void TP_ID(__lttng_seq_stop__, TRACE_SYSTEM)(struct seq_file *m, - void *p) -{ -} - -static int TP_ID(__lttng_seq_show__, TRACE_SYSTEM)(struct seq_file *m, - void *p) -{ - const struct lttng_event_desc *desc = p; - int i; - - seq_printf(m, "event {\n" - "\tname = %s;\n" - "\tid = UNKNOWN;\n" - "\tstream = UNKNOWN;\n" - "\tfields = {\n", - desc->name); - for (i = 0; i < desc->nr_fields; i++) { - if (desc->fields[i].type.name) /* Named type */ - seq_printf(m, "\t\t%s", - desc->fields[i].type.name); - else /* Nameless type */ - lttng_print_event_type(m, 2, &desc->fields[i].type); - seq_printf(m, " %s;\n", desc->fields[i].name); - } - seq_printf(m, "\t};\n"); - seq_printf(m, "};\n"); - return 0; -} -static const -struct seq_operations TP_ID(__lttng_types_seq_ops__, TRACE_SYSTEM) = { - .start = TP_ID(__lttng_seq_start__, TRACE_SYSTEM), - .next = TP_ID(__lttng_seq_next__, TRACE_SYSTEM), - .stop = TP_ID(__lttng_seq_stop__, TRACE_SYSTEM), - .show = TP_ID(__lttng_seq_show__, TRACE_SYSTEM), +/* non-const because list head will be modified when registered. */ +static struct lttng_probe_desc TP_ID(__probe_desc___, TRACE_SYSTEM) = { + .event_desc = TP_ID(__event_desc___, TRACE_SYSTEM), + .nr_events = ARRAY_SIZE(TP_ID(__event_desc___, TRACE_SYSTEM)), }; -static int -TP_ID(__lttng_types_open__, TRACE_SYSTEM)(struct inode *inode, struct file *file) -{ - return seq_open(file, &TP_ID(__lttng_types_seq_ops__, TRACE_SYSTEM)); -} - -static const -struct file_operations TP_ID(__lttng_types_fops__, TRACE_SYSTEM) = { - .open = TP_ID(__lttng_types_open__, TRACE_SYSTEM), - .read = seq_read, - .llseek = seq_lseek, - .release = seq_release_private, -}; - -static struct dentry *TP_ID(__lttng_types_dentry__, TRACE_SYSTEM); - -static int TP_ID(__lttng_types_init__, TRACE_SYSTEM)(void) -{ - int ret = 0; - - TP_ID(__lttng_types_dentry__, TRACE_SYSTEM) = - debugfs_create_file("lttng-events-" __stringify(TRACE_SYSTEM), - S_IWUSR, NULL, NULL, - &TP_ID(__lttng_types_fops__, TRACE_SYSTEM)); - if (IS_ERR(TP_ID(__lttng_types_dentry__, TRACE_SYSTEM)) - || !TP_ID(__lttng_types_dentry__, TRACE_SYSTEM)) { - printk(KERN_ERR "Error creating LTTng type export file\n"); - ret = -ENOMEM; - goto error; - } -error: - return ret; -} - -module_init_eval(__lttng_types_init__, TRACE_SYSTEM); - -static void TP_ID(__lttng_types_exit__, TRACE_SYSTEM)(void) -{ - debugfs_remove(TP_ID(__lttng_types_dentry__, TRACE_SYSTEM)); -} - -module_exit_eval(__lttng_types_exit__, TRACE_SYSTEM); - -#undef module_init_eval -#undef module_exit_eval #undef TP_ID1 #undef TP_ID /* - * Stage 4 of the trace events. + * Stage 6 of the trace events. * * Create static inline function that calculates event size. */ @@ -278,7 +248,7 @@ module_exit_eval(__lttng_types_exit__, TRACE_SYSTEM); #undef __field #define __field(_type, _item) \ - __event_len += lib_ring_buffer_align(__event_len, __alignof__(_type)); \ + __event_len += lib_ring_buffer_align(__event_len, ltt_alignof(_type)); \ __event_len += sizeof(_type); #undef __field_ext @@ -286,15 +256,25 @@ module_exit_eval(__lttng_types_exit__, TRACE_SYSTEM); #undef __array #define __array(_type, _item, _length) \ - __event_len += lib_ring_buffer_align(__event_len, __alignof__(_type)); \ + __event_len += lib_ring_buffer_align(__event_len, ltt_alignof(_type)); \ __event_len += sizeof(_type) * (_length); +#undef __array_text +#define __array_text(_type, _item, _length) \ + __array(_type, _item, _length) + #undef __dynamic_array #define __dynamic_array(_type, _item, _length) \ - __event_len += lib_ring_buffer_align(__event_len, __alignof__(u32)); \ + __event_len += lib_ring_buffer_align(__event_len, ltt_alignof(u32)); \ __event_len += sizeof(u32); \ - __event_len += lib_ring_buffer_align(__event_len, __alignof__(_type)); \ - __event_len += sizeof(_type) * (_length); + __event_len += lib_ring_buffer_align(__event_len, ltt_alignof(_type)); \ + __dynamic_len[__dynamic_len_idx] = (_length); \ + __event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx]; \ + __dynamic_len_idx++; + +#undef __dynamic_array_text +#define __dynamic_array_text(_type, _item, _length) \ + __dynamic_array(_type, _item, _length) #undef __string #define __string(_item, _src) \ @@ -321,10 +301,8 @@ static inline size_t __event_get_size__##_name(size_t *__dynamic_len, _proto) \ #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - - /* - * Stage 5 of the trace events. + * Stage 7 of the trace events. * * Create static inline function that calculates event payload alignment. */ @@ -335,19 +313,27 @@ static inline size_t __event_get_size__##_name(size_t *__dynamic_len, _proto) \ #undef __field #define __field(_type, _item) \ - __event_align = max_t(size_t, __event_align, __alignof__(_type)); + __event_align = max_t(size_t, __event_align, ltt_alignof(_type)); #undef __field_ext #define __field_ext(_type, _item, _filter_type) __field(_type, _item) #undef __array #define __array(_type, _item, _length) \ - __event_align = max_t(size_t, __event_align, __alignof__(_type)); + __event_align = max_t(size_t, __event_align, ltt_alignof(_type)); + +#undef __array_text +#define __array_text(_type, _item, _length) \ + __array(_type, _item, _length) #undef __dynamic_array #define __dynamic_array(_type, _item, _length) \ - __event_align = max_t(size_t, __event_align, __alignof__(u32)); \ - __event_align = max_t(size_t, __event_align, __alignof__(_type)); + __event_align = max_t(size_t, __event_align, ltt_alignof(u32)); \ + __event_align = max_t(size_t, __event_align, ltt_alignof(_type)); + +#undef __dynamic_array_text +#define __dynamic_array_text(_type, _item, _length) \ + __dynamic_array(_type, _item, _length) #undef __string #define __string(_item, _src) @@ -370,9 +356,54 @@ static inline size_t __event_get_align__##_name(_proto) \ #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) +/* + * Stage 8 of the trace events. + * + * Create structure declaration that allows the "assign" macros to access the + * field types. + */ + +#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */ + +/* Named field types must be defined in lttng-types.h */ + +#undef __field +#define __field(_type, _item) _type _item; + +#undef __field_ext +#define __field_ext(_type, _item, _filter_type) __field(_type, _item) + +#undef __array +#define __array(_type, _item, _length) _type _item; + +#undef __array_text +#define __array_text(_type, _item, _length) \ + __array(_type, _item, _length) + +#undef __dynamic_array +#define __dynamic_array(_type, _item, _length) _type _item; + +#undef __dynamic_array_text +#define __dynamic_array_text(_type, _item, _length) \ + __dynamic_array(_type, _item, _length) + +#undef __string +#define __string(_item, _src) char _item; + +#undef TP_STRUCT__entry +#define TP_STRUCT__entry(args...) args + +#undef DECLARE_EVENT_CLASS +#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \ +struct __event_typemap__##_name { \ + _tstruct \ +}; + +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) + /* - * Stage 6 of the trace events. + * Stage 9 of the trace events. * * Create the probe function : call even size calculation and write event data * into the buffer. @@ -386,7 +417,6 @@ static inline size_t __event_get_align__##_name(_proto) \ #undef __field #define __field(_type, _item) \ - lib_ring_buffer_align_ctx(&ctx, __alignof__(_type)); \ goto __assign_##_item; \ __end_field_##_item: @@ -395,19 +425,24 @@ __end_field_##_item: #undef __array #define __array(_type, _item, _length) \ - lib_ring_buffer_align_ctx(&ctx, __alignof__(_type)); \ goto __assign_##_item; \ __end_field_##_item: +#undef __array_text +#define __array_text(_type, _item, _length) \ + __array(_type, _item, _length) + #undef __dynamic_array #define __dynamic_array(_type, _item, _length) \ - lib_ring_buffer_align_ctx(&ctx, __alignof__(u32)); \ goto __assign_##_item##_1; \ __end_field_##_item##_1: \ - lib_ring_buffer_align_ctx(&ctx, __alignof__(_type)); \ goto __assign_##_item##_2; \ __end_field_##_item##_2: +#undef __dynamic_array_text +#define __dynamic_array_text(_type, _item, _length) \ + __dynamic_array(_type, _item, _length) + #undef __string #define __string(_item, _src) \ goto __assign_##_item; \ @@ -421,32 +456,39 @@ __end_field_##_item: #define tp_assign(dest, src) \ __assign_##dest: \ { \ - __typeof__(src) __tmp = (src); \ - __chan->ops->event_write(&ctx, &__tmp, sizeof(src)); \ + __typeof__(__typemap.dest) __tmp = (src); \ + lib_ring_buffer_align_ctx(&ctx, ltt_alignof(__tmp)); \ + __chan->ops->event_write(&ctx, &__tmp, sizeof(__tmp)); \ } \ goto __end_field_##dest; #undef tp_memcpy #define tp_memcpy(dest, src, len) \ __assign_##dest: \ + if (0) \ + (void) __typemap.dest; \ + lib_ring_buffer_align_ctx(&ctx, ltt_alignof(__typemap.dest)); \ __chan->ops->event_write(&ctx, src, len); \ goto __end_field_##dest; #undef tp_memcpy_dyn -#define tp_memcpy_dyn(dest, src, len) \ +#define tp_memcpy_dyn(dest, src) \ __assign_##dest##_1: \ { \ - __typeof__(len) __tmpl = (len); \ + u32 __tmpl = __dynamic_len[__dynamic_len_idx]; \ + lib_ring_buffer_align_ctx(&ctx, ltt_alignof(u32)); \ __chan->ops->event_write(&ctx, &__tmpl, sizeof(u32)); \ } \ goto __end_field_##dest##_1; \ __assign_##dest##_2: \ - __chan->ops->event_write(&ctx, src, len); \ + lib_ring_buffer_align_ctx(&ctx, ltt_alignof(__typemap.dest)); \ + __chan->ops->event_write(&ctx, src, \ + sizeof(__typemap.dest) * __get_dynamic_array_len(dest));\ goto __end_field_##dest##_2; #undef tp_strcpy #define tp_strcpy(dest, src) \ - tp_memcpy(dest, src, __get_dynamic_array_len(dest)); \ + tp_memcpy(dest, src, __get_dynamic_array_len(dest)) /* Named field types must be defined in lttng-types.h */ @@ -482,15 +524,18 @@ static void __event_probe__##_name(void *__data, _proto) \ size_t __event_len, __event_align; \ size_t __dynamic_len_idx = 0; \ size_t __dynamic_len[ARRAY_SIZE(__event_fields___##_name)]; \ + struct __event_typemap__##_name __typemap; \ int __ret; \ \ if (0) \ (void) __dynamic_len_idx; /* don't warn if unused */ \ + if (!ACCESS_ONCE(__chan->session->active)) \ + return; \ __event_len = __event_get_size__##_name(__dynamic_len, _args); \ __event_align = __event_get_align__##_name(_args); \ - lib_ring_buffer_ctx_init(&ctx, __chan->chan, NULL, __event_len, \ + lib_ring_buffer_ctx_init(&ctx, __chan->chan, __event, __event_len, \ __event_align, -1); \ - __ret = __chan->ops->event_reserve(&ctx); \ + __ret = __chan->ops->event_reserve(&ctx, __event->id); \ if (__ret < 0) \ return; \ /* Control code (field ordering) */ \ @@ -503,694 +548,37 @@ static void __event_probe__##_name(void *__data, _proto) \ #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -#if 0 - -#include - -/* - * DECLARE_EVENT_CLASS can be used to add a generic function - * handlers for events. That is, if all events have the same - * parameters and just have distinct trace points. - * Each tracepoint can be defined with DEFINE_EVENT and that - * will map the DECLARE_EVENT_CLASS to the tracepoint. - * - * TRACE_EVENT is a one to one mapping between tracepoint and template. - */ -#undef TRACE_EVENT -#define TRACE_EVENT(name, proto, args, tstruct, assign, print) \ - DECLARE_EVENT_CLASS(name, \ - PARAMS(proto), \ - PARAMS(args), \ - PARAMS(tstruct), \ - PARAMS(assign), \ - PARAMS(print)); \ - DEFINE_EVENT(name, name, PARAMS(proto), PARAMS(args)); - - -#undef __field -#define __field(type, item) type item; - -#undef __field_ext -#define __field_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 TP_STRUCT__entry -#define TP_STRUCT__entry(args...) args - -#undef DECLARE_EVENT_CLASS -#define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) \ - struct ftrace_raw_##name { \ - struct trace_entry ent; \ - tstruct \ - char __data[0]; \ - }; \ - \ - static struct ftrace_event_class event_class_##name; - -#undef DEFINE_EVENT -#define DEFINE_EVENT(template, name, proto, args) \ - static struct ftrace_event_call __used \ - __attribute__((__aligned__(4))) event_##name - -#undef DEFINE_EVENT_PRINT -#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ - DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) - -/* Callbacks are meaningless to ftrace. */ -#undef TRACE_EVENT_FN -#define TRACE_EVENT_FN(name, proto, args, tstruct, \ - assign, print, reg, unreg) \ - TRACE_EVENT(name, PARAMS(proto), PARAMS(args), \ - PARAMS(tstruct), PARAMS(assign), PARAMS(print)) \ - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - - -/* - * Stage 2 of the trace events. - * - * Create static inline function that calculates event size. - */ - -#undef __field -#define __field(type, item) - -#undef __field_ext -#define __field_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 DECLARE_EVENT_CLASS -#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \ - struct ftrace_data_offsets_##call { \ - tstruct; \ - }; - -#undef DEFINE_EVENT -#define DEFINE_EVENT(template, name, proto, args) - -#undef DEFINE_EVENT_PRINT -#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ - DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -/* - * Stage 3 of the trace events. - * - * Create the probe function : call even size calculation and write event data - * into the buffer. - */ - -#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_str -#define __get_str(field) (char *)__get_dynamic_array(field) - -#undef __print_flags -#define __print_flags(flag, delim, flag_array...) \ - ({ \ - static const struct trace_print_flags __flags[] = \ - { flag_array, { -1, NULL }}; \ - ftrace_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 }}; \ - ftrace_print_symbols_seq(p, value, symbols); \ - }) - -#undef __print_hex -#define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len) - -#undef DECLARE_EVENT_CLASS -#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \ -static notrace enum print_line_t \ -ftrace_raw_output_##call(struct trace_iterator *iter, int flags, \ - struct trace_event *trace_event) \ -{ \ - struct ftrace_event_call *event; \ - struct trace_seq *s = &iter->seq; \ - struct ftrace_raw_##call *field; \ - struct trace_entry *entry; \ - struct trace_seq *p = &iter->tmp_seq; \ - int ret; \ - \ - event = container_of(trace_event, struct ftrace_event_call, \ - event); \ - \ - entry = iter->ent; \ - \ - if (entry->type != event->event.type) { \ - WARN_ON_ONCE(1); \ - return TRACE_TYPE_UNHANDLED; \ - } \ - \ - field = (typeof(field))entry; \ - \ - trace_seq_init(p); \ - ret = trace_seq_printf(s, "%s: ", event->name); \ - if (ret) \ - ret = trace_seq_printf(s, print); \ - if (!ret) \ - return TRACE_TYPE_PARTIAL_LINE; \ - \ - return TRACE_TYPE_HANDLED; \ -} \ -static struct trace_event_functions ftrace_event_type_funcs_##call = { \ - .trace = ftrace_raw_output_##call, \ -}; - -#undef DEFINE_EVENT_PRINT -#define DEFINE_EVENT_PRINT(template, call, proto, args, print) \ -static notrace enum print_line_t \ -ftrace_raw_output_##call(struct trace_iterator *iter, int flags, \ - struct trace_event *event) \ -{ \ - struct trace_seq *s = &iter->seq; \ - struct ftrace_raw_##template *field; \ - struct trace_entry *entry; \ - struct trace_seq *p = &iter->tmp_seq; \ - int ret; \ - \ - entry = iter->ent; \ - \ - if (entry->type != event_##call.event.type) { \ - WARN_ON_ONCE(1); \ - return TRACE_TYPE_UNHANDLED; \ - } \ - \ - field = (typeof(field))entry; \ - \ - trace_seq_init(p); \ - ret = trace_seq_printf(s, "%s: ", #call); \ - if (ret) \ - ret = trace_seq_printf(s, print); \ - if (!ret) \ - return TRACE_TYPE_PARTIAL_LINE; \ - \ - return TRACE_TYPE_HANDLED; \ -} \ -static struct trace_event_functions ftrace_event_type_funcs_##call = { \ - .trace = ftrace_raw_output_##call, \ -}; - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -#undef __field_ext -#define __field_ext(type, item, filter_type) \ - ret = trace_define_field(event_call, #type, #item, \ - offsetof(typeof(field), item), \ - sizeof(field.item), \ - is_signed_type(type), filter_type); \ - if (ret) \ - return ret; - -#undef __field -#define __field(type, item) __field_ext(type, item, FILTER_OTHER) - -#undef __array -#define __array(type, item, len) \ - BUILD_BUG_ON(len > MAX_FILTER_STR_VAL); \ - ret = trace_define_field(event_call, #type "[" #len "]", #item, \ - offsetof(typeof(field), item), \ - sizeof(field.item), \ - is_signed_type(type), FILTER_OTHER); \ - if (ret) \ - return ret; - -#undef __dynamic_array -#define __dynamic_array(type, item, len) \ - ret = trace_define_field(event_call, "__data_loc " #type "[]", #item, \ - offsetof(typeof(field), __data_loc_##item), \ - sizeof(field.__data_loc_##item), \ - is_signed_type(type), FILTER_OTHER); - -#undef __string -#define __string(item, src) __dynamic_array(char, item, -1) - -#undef DECLARE_EVENT_CLASS -#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, func, print) \ -static int notrace \ -ftrace_define_fields_##call(struct ftrace_event_call *event_call) \ -{ \ - struct ftrace_raw_##call field; \ - int ret; \ - \ - tstruct; \ - \ - return ret; \ -} - -#undef DEFINE_EVENT -#define DEFINE_EVENT(template, name, proto, args) - -#undef DEFINE_EVENT_PRINT -#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ - DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - -/* - * 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 __array -#define __array(type, item, len) - -#undef __dynamic_array -#define __dynamic_array(type, item, len) \ - __data_offsets->item = __data_size + \ - offsetof(typeof(*entry), __data); \ - __data_offsets->item |= (len * sizeof(type)) << 16; \ - __data_size += (len) * sizeof(type); - -#undef __string -#define __string(item, src) __dynamic_array(char, item, strlen(src) + 1) - -#undef DECLARE_EVENT_CLASS -#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \ -static inline notrace int ftrace_get_offsets_##call( \ - struct ftrace_data_offsets_##call *__data_offsets, proto) \ -{ \ - int __data_size = 0; \ - struct ftrace_raw_##call __maybe_unused *entry; \ - \ - tstruct; \ - \ - return __data_size; \ -} - -#undef DEFINE_EVENT -#define DEFINE_EVENT(template, name, proto, args) - -#undef DEFINE_EVENT_PRINT -#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ - DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) - -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) - /* - * Stage 4 of the trace events. - * - * Override the macros in to include the following: - * - * For those macros defined with TRACE_EVENT: - * - * static struct ftrace_event_call event_; - * - * static void ftrace_raw_event_(void *__data, proto) - * { - * struct ftrace_event_call *event_call = __data; - * struct ftrace_data_offsets_ __maybe_unused __data_offsets; - * struct ring_buffer_event *event; - * struct ftrace_raw_ *entry; <-- defined in stage 1 - * struct ring_buffer *buffer; - * unsigned long irq_flags; - * int __data_size; - * int pc; - * - * local_save_flags(irq_flags); - * pc = preempt_count(); - * - * __data_size = ftrace_get_offsets_(&__data_offsets, args); - * - * event = trace_current_buffer_lock_reserve(&buffer, - * event_->event.type, - * sizeof(*entry) + __data_size, - * irq_flags, pc); - * if (!event) - * return; - * entry = ring_buffer_event_data(event); - * - * { ; } <-- Here we assign the entries by the __field and - * __array macros. + * Stage 10 of the trace events. * - * if (!filter_current_check_discard(buffer, event_call, entry, event)) - * trace_current_buffer_unlock_commit(buffer, - * event, irq_flags, pc); - * } - * - * static struct trace_event ftrace_event_type_ = { - * .trace = ftrace_raw_output_, <-- stage 2 - * }; - * - * static const char print_fmt_[] = ; - * - * static struct ftrace_event_class __used event_class_