X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=probes%2Flttng-events.h;h=bf2e2b9d1df5364cc3213fc70345c38f21d7fd5a;hb=f9771d396f35b66330bc6cc3e5ba5dceb741a99d;hp=61fac2fec8ff618cecd409cea610d016218fcfc6;hpb=299338c88005db478c3a62ea58862eb0ba267d6d;p=lttng-modules.git diff --git a/probes/lttng-events.h b/probes/lttng-events.h index 61fac2fe..bf2e2b9d 100644 --- a/probes/lttng-events.h +++ b/probes/lttng-events.h @@ -1,39 +1,78 @@ -#include -#include - /* - * Macros mapping tp_assign() to "=", tp_memcpy() to memcpy() and tp_strcpy() to - * strcpy(). + * lttng-events.h + * + * Copyright (C) 2009 Steven Rostedt + * Copyright (C) 2009-2012 Mathieu Desnoyers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; only + * version 2.1 of the License. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#undef tp_assign -#define tp_assign(dest, src) \ - lib_ring_buffer_align_ctx(config, &ctx, sizeof(src)); \ - lib_ring_buffer_write(config, &ctx, &src, sizeof(src)); - -#undef tp_memcpy -#define tp_memcpy(dest, src, len) \ - lib_ring_buffer_align_ctx(config, &ctx, sizeof(*(src))); \ - lib_ring_buffer_write(config, &ctx, &src, len); +#include +#include +#include "lttng.h" +#include "lttng-types.h" +#include "lttng-probe-user.h" +#include "../wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */ +#include "../wrapper/ringbuffer/frontend_types.h" +#include "../lttng-events.h" +#include "../lttng-tracer-core.h" -/* TODO */ -#undef tp_strcpy -#define tp_strcpy(dest, src) __assign_str(dest, src); - -struct lttng_event_field { - const char *name; - const struct lttng_type type; -}; - -struct lttng_event_desc { - const struct lttng_event_field *fields; -}; +/* + * Macro declarations used for all stages. + */ /* - * Stage 1 of the trace events. - * - * Create event field type metadata section. - * Each event produce an array of fields. + * LTTng name mapping macros. LTTng remaps some of the kernel events to + * enforce name-spacing. */ +#undef TRACE_EVENT_MAP +#define TRACE_EVENT_MAP(name, map, proto, args, tstruct, assign, print) \ + DECLARE_EVENT_CLASS(map, \ + PARAMS(proto), \ + PARAMS(args), \ + PARAMS(tstruct), \ + PARAMS(assign), \ + PARAMS(print)) \ + DEFINE_EVENT_MAP(map, name, map, PARAMS(proto), PARAMS(args)) + +#undef TRACE_EVENT_MAP_NOARGS +#define TRACE_EVENT_MAP_NOARGS(name, map, tstruct, assign, print) \ + DECLARE_EVENT_CLASS_NOARGS(map, \ + PARAMS(tstruct), \ + PARAMS(assign), \ + PARAMS(print)) \ + DEFINE_EVENT_MAP_NOARGS(map, name, map) + +#undef DEFINE_EVENT_PRINT_MAP +#define DEFINE_EVENT_PRINT_MAP(template, name, map, proto, args, print) \ + DEFINE_EVENT_MAP(template, name, map, PARAMS(proto), PARAMS(args)) + +/* Callbacks are meaningless to LTTng. */ +#undef TRACE_EVENT_FN_MAP +#define TRACE_EVENT_FN_MAP(name, map, proto, args, tstruct, \ + assign, print, reg, unreg) \ + TRACE_EVENT_MAP(name, map, PARAMS(proto), PARAMS(args), \ + PARAMS(tstruct), PARAMS(assign), PARAMS(print)) \ + +#undef TRACE_EVENT_CONDITION_MAP +#define TRACE_EVENT_CONDITION_MAP(name, map, proto, args, cond, tstruct, assign, print) \ + TRACE_EVENT_MAP(name, map, \ + PARAMS(proto), \ + PARAMS(args), \ + PARAMS(tstruct), \ + PARAMS(assign), \ + PARAMS(print)) /* * DECLARE_EVENT_CLASS can be used to add a generic function @@ -44,894 +83,786 @@ struct lttng_event_desc { * * 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)) -/* Named field types must be defined in lttng-types.h */ +#undef TRACE_EVENT +#define TRACE_EVENT(name, proto, args, tstruct, assign, print) \ + TRACE_EVENT_MAP(name, name, \ + PARAMS(proto), \ + PARAMS(args), \ + PARAMS(tstruct), \ + PARAMS(assign), \ + PARAMS(print)) + +#undef TRACE_EVENT_NOARGS +#define TRACE_EVENT_NOARGS(name, tstruct, assign, print) \ + TRACE_EVENT_MAP_NOARGS(name, name, \ + PARAMS(tstruct), \ + PARAMS(assign), \ + PARAMS(print)) -#undef __field -#define __field(_type, _item) \ - { .name = #_item, .type = { .atype = atype_integer, .name = #_type} }, +#undef DEFINE_EVENT_PRINT +#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ + DEFINE_EVENT_PRINT_MAP(template, name, name, \ + PARAMS(proto), PARAMS(args), PARAMS(print_)) -#undef __field_ext -#define __field_ext(_type, _item, _filter_type) \ - { .name = #_item, .type = { .atype = atype_integer, .name = #_type} }, +#undef TRACE_EVENT_FN +#define TRACE_EVENT_FN(name, proto, args, tstruct, \ + assign, print, reg, unreg) \ + TRACE_EVENT_FN_MAP(name, name, PARAMS(proto), PARAMS(args), \ + PARAMS(tstruct), PARAMS(assign), PARAMS(print), \ + PARAMS(reg), PARAMS(unreg)) \ -#undef __array -#define __array(_type, _item, _length) \ - { \ - .name = #_item, \ - .type = { \ - .atype = atype_array, \ - .name = NULL, \ - .u.array.elem_type = #_type, \ - .u.array.length = _length, \ - }, \ - }, +#undef DEFINE_EVENT +#define DEFINE_EVENT(template, name, proto, args) \ + DEFINE_EVENT_MAP(template, name, name, PARAMS(proto), PARAMS(args)) + +#undef DEFINE_EVENT_NOARGS +#define DEFINE_EVENT_NOARGS(template, name) \ + DEFINE_EVENT_MAP_NOARGS(template, name, name) + +#undef TRACE_EVENT_CONDITION +#define TRACE_EVENT_CONDITION(name, proto, args, cond, tstruct, assign, print) \ + TRACE_EVENT_CONDITION_MAP(name, name, \ + PARAMS(proto), \ + PARAMS(args), \ + PARAMS(cond), \ + PARAMS(tstruct), \ + PARAMS(assign), \ + PARAMS(print)) -#undef __dynamic_array -#define __dynamic_array(_type, _item, _length) \ - { \ - .name = #_item, \ - .type = { \ - .atype = atype_sequence, \ - .name = NULL, \ - .u.sequence.elem_type = #_type, \ - .u.sequence.length_type = "u32", \ - }, \ - }, +/* + * 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. + */ -#undef __string -#define __string(_item, _src) \ - { \ - .name = _item, \ - .type = { \ - .atype = atype_string, \ - .name = NULL, \ - .u.string.encoding = lttng_encode_UTF8, \ - }, \ - }, +#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */ #undef TP_PROTO -#define TP_PROTO(args...) +#define TP_PROTO(args...) args #undef TP_ARGS -#define TP_ARGS(args...) - -#undef TP_STRUCT__entry -#define TP_STRUCT__entry(args...) args /* Only one used in this phase */ - -#undef TP_fast_assign -#define TP_fast_assign(args...) - -#undef TP_printk -#define TP_printk(args...) - -#undef DECLARE_EVENT_CLASS -#define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) \ - static const struct lttng_event_field __event_fields___##name[] = { \ - tstruct \ - }; - -#undef DEFINE_EVENT -#define DEFINE_EVENT(template, name, proto, args) +#define TP_ARGS(args...) args -#undef DEFINE_EVENT_PRINT -#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ - DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) +#undef DEFINE_EVENT_MAP +#define DEFINE_EVENT_MAP(_template, _name, _map, _proto, _args) \ +void trace_##_name(_proto); -/* Callbacks are meaningless to LTTng. */ -#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)) \ +#undef DEFINE_EVENT_MAP_NOARGS +#define DEFINE_EVENT_MAP_NOARGS(_template, _name, _map) \ +void trace_##_name(void *__data); #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) /* * Stage 2 of the trace events. * - * Create an array of events. + * Create event field type metadata section. + * Each event produce an array of fields. */ -/* - * 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)) +#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */ /* Named field types must be defined in lttng-types.h */ +#undef __field_full +#define __field_full(_type, _item, _order, _base) \ + { \ + .name = #_item, \ + .type = __type_integer(_type, _order, _base, none), \ + }, + #undef __field -#define __field(_type, _item) +#define __field(_type, _item) \ + __field_full(_type, _item, __BYTE_ORDER, 10) #undef __field_ext -#define __field_ext(_type, _item, _filter_type) +#define __field_ext(_type, _item, _filter_type) \ + __field(_type, _item) -#undef __array -#define __array(_type, _item, _length) +#undef __field_hex +#define __field_hex(_type, _item) \ + __field_full(_type, _item, __BYTE_ORDER, 16) -#undef __dynamic_array -#define __dynamic_array(_type, _item, _length) +#undef __field_network +#define __field_network(_type, _item) \ + __field_full(_type, _item, __BIG_ENDIAN, 10) -#undef __string -#define __string(_item, _src) +#undef __field_network_hex +#define __field_network_hex(_type, _item) \ + __field_full(_type, _item, __BIG_ENDIAN, 16) -#undef TP_PROTO -#define TP_PROTO(args...) +#undef __array_enc_ext +#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding)\ + { \ + .name = #_item, \ + .type = \ + { \ + .atype = atype_array, \ + .u.array = \ + { \ + .length = _length, \ + .elem_type = __type_integer(_type, _order, _base, _encoding), \ + }, \ + }, \ + }, -#undef TP_ARGS -#define TP_ARGS(args...) +#undef __array +#define __array(_type, _item, _length) \ + __array_enc_ext(_type, _item, _length, __BYTE_ORDER, 10, none) -#undef TP_STRUCT__entry -#define TP_STRUCT__entry(args...) +#undef __array_text +#define __array_text(_type, _item, _length) \ + __array_enc_ext(_type, _item, _length, __BYTE_ORDER, 10, UTF8) -#undef TP_fast_assign -#define TP_fast_assign(args...) +#undef __array_hex +#define __array_hex(_type, _item, _length) \ + __array_enc_ext(_type, _item, _length, __BYTE_ORDER, 16, none) -#undef TP_printk -#define TP_printk(args...) +#undef __dynamic_array_enc_ext +#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding) \ + { \ + .name = #_item, \ + .type = \ + { \ + .atype = atype_sequence, \ + .u.sequence = \ + { \ + .length_type = __type_integer(u32, __BYTE_ORDER, 10, none), \ + .elem_type = __type_integer(_type, _order, _base, _encoding), \ + }, \ + }, \ + }, -#undef DECLARE_EVENT_CLASS -#define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print) \ - { .fields = __event_fields___##name }, +#undef __dynamic_array_enc_ext_2 +#define __dynamic_array_enc_ext_2(_type, _item, _length1, _length2, _order, _base, _encoding) \ + __dynamic_array_enc_ext(_type, _item, _length1 + _length2, _order, _base, _encoding) -#undef DEFINE_EVENT -#define DEFINE_EVENT(template, name, proto, args) +#undef __dynamic_array +#define __dynamic_array(_type, _item, _length) \ + __dynamic_array_enc_ext(_type, _item, _length, __BYTE_ORDER, 10, none) -#undef DEFINE_EVENT_PRINT -#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ - DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) +#undef __dynamic_array_text +#define __dynamic_array_text(_type, _item, _length) \ + __dynamic_array_enc_ext(_type, _item, _length, __BYTE_ORDER, 10, UTF8) -/* Callbacks are meaningless to LTTng. */ -#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)) \ +#undef __dynamic_array_hex +#define __dynamic_array_hex(_type, _item, _length) \ + __dynamic_array_enc_ext(_type, _item, _length, __BYTE_ORDER, 16, none) -#define TRACE_EVENT_DESC_1(_system) __event_desc___##_system -#define TRACE_EVENT_DESC(_system) TRACE_EVENT_DESC_1(_system) +#undef __dynamic_array_text_2 +#define __dynamic_array_text_2(_type, _item, _length1, _length2) \ + __dynamic_array_enc_ext_2(_type, _item, _length1, _length2, __BYTE_ORDER, 10, UTF8) -static const struct lttng_event_desc TRACE_EVENT_DESC(TRACE_SYSTEM)[] = { -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) -}; +#undef __string +#define __string(_item, _src) \ + { \ + .name = #_item, \ + .type = \ + { \ + .atype = atype_string, \ + .u.basic.string.encoding = lttng_encode_UTF8, \ + }, \ + }, + +#undef __string_from_user +#define __string_from_user(_item, _src) \ + __string(_item, _src) + +#undef TP_STRUCT__entry +#define TP_STRUCT__entry(args...) args /* Only one used in this phase */ + +#undef DECLARE_EVENT_CLASS_NOARGS +#define DECLARE_EVENT_CLASS_NOARGS(_name, _tstruct, _assign, _print) \ + static const struct lttng_event_field __event_fields___##_name[] = { \ + _tstruct \ + }; -#undef TRACE_EVENT_DESC_1 -#undef TRACE_EVENT_DESC +#undef DECLARE_EVENT_CLASS +#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \ + DECLARE_EVENT_CLASS_NOARGS(_name, PARAMS(_tstruct), PARAMS(_assign), \ + PARAMS(_print)) -#if 0 +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) /* * Stage 3 of the trace events. * - * Create static inline function that calculates event size. + * 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); + +#undef DECLARE_EVENT_CLASS_NOARGS +#define DECLARE_EVENT_CLASS_NOARGS(_name, _tstruct, _assign, _print) \ +static void __event_probe__##_name(void *__data); #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) /* - * Stage 4 of the trace events. + * Stage 3.9 of the trace events. * - * Create the probe function : call even size calculation and write event data - * into the buffer. + * Create event descriptions. */ +/* Named field types must be defined in lttng-types.h */ +#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */ -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) +#ifndef TP_PROBE_CB +#define TP_PROBE_CB(_template) &__event_probe__##_template +#endif +#undef DEFINE_EVENT_MAP_NOARGS +#define DEFINE_EVENT_MAP_NOARGS(_template, _name, _map) \ +static const struct lttng_event_desc __event_desc___##_map = { \ + .fields = __event_fields___##_template, \ + .name = #_map, \ + .probe_callback = (void *) TP_PROBE_CB(_template), \ + .nr_fields = ARRAY_SIZE(__event_fields___##_template), \ + .owner = THIS_MODULE, \ +}; +#undef DEFINE_EVENT_MAP +#define DEFINE_EVENT_MAP(_template, _name, _map, _proto, _args) \ + DEFINE_EVENT_MAP_NOARGS(_template, _name, _map) +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) -#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. + * Stage 4 of the trace events. * - * TRACE_EVENT is a one to one mapping between tracepoint and template. + * Create an array of event description pointers. */ -#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; +/* Named field types must be defined in lttng-types.h */ -#undef __field_ext -#define __field_ext(type, item, filter_type) type item; +#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */ -#undef __array -#define __array(type, item, len) type item[len]; +#undef DEFINE_EVENT_MAP_NOARGS +#define DEFINE_EVENT_MAP_NOARGS(_template, _name, _map) \ + &__event_desc___##_map, -#undef __dynamic_array -#define __dynamic_array(type, item, len) u32 __data_loc_##item; +#undef DEFINE_EVENT_MAP +#define DEFINE_EVENT_MAP(_template, _name, _map, _proto, _args) \ + DEFINE_EVENT_MAP_NOARGS(_template, _name, _map) -#undef __string -#define __string(item, src) __dynamic_array(char, item, -1) +#define TP_ID1(_token, _system) _token##_system +#define TP_ID(_token, _system) TP_ID1(_token, _system) -#undef TP_STRUCT__entry -#define TP_STRUCT__entry(args...) args +static const struct lttng_event_desc *TP_ID(__event_desc___, TRACE_SYSTEM)[] = { +#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) +}; -#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 TP_ID1 +#undef TP_ID -#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)) +/* + * Stage 5 of the trace events. + * + * Create a toplevel descriptor for the whole probe. + */ -/* 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)) \ +#define TP_ID1(_token, _system) _token##_system +#define TP_ID(_token, _system) TP_ID1(_token, _system) -#include TRACE_INCLUDE(TRACE_INCLUDE_FILE) +/* non-const because list head will be modified when registered. */ +static __used 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)), +}; +#undef TP_ID1 +#undef TP_ID /* - * Stage 2 of the trace events. + * Stage 6 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) +#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */ -#undef __array -#define __array(type, item, len) +/* Named field types must be defined in lttng-types.h */ -#undef __dynamic_array -#define __dynamic_array(type, item, len) u32 item; +#undef __field_full +#define __field_full(_type, _item, _order, _base) \ + __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \ + __event_len += sizeof(_type); + +#undef __array_enc_ext +#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding) \ + __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \ + __event_len += sizeof(_type) * (_length); + +#undef __dynamic_array_enc_ext +#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding)\ + __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(u32)); \ + __event_len += sizeof(u32); \ + __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \ + __dynamic_len[__dynamic_len_idx] = (_length); \ + __event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx]; \ + __dynamic_len_idx++; + +#undef __dynamic_array_enc_ext_2 +#define __dynamic_array_enc_ext_2(_type, _item, _length1, _length2, _order, _base, _encoding)\ + __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(u32)); \ + __event_len += sizeof(u32); \ + __event_len += lib_ring_buffer_align(__event_len, lttng_alignof(_type)); \ + __dynamic_len[__dynamic_len_idx] = (_length1); \ + __event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx]; \ + __dynamic_len_idx++; \ + __dynamic_len[__dynamic_len_idx] = (_length2); \ + __event_len += sizeof(_type) * __dynamic_len[__dynamic_len_idx]; \ + __dynamic_len_idx++; #undef __string -#define __string(item, src) __dynamic_array(char, item, -1) +#define __string(_item, _src) \ + __event_len += __dynamic_len[__dynamic_len_idx++] = strlen(_src) + 1; -#undef DECLARE_EVENT_CLASS -#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print) \ - struct ftrace_data_offsets_##call { \ - tstruct; \ - }; +/* + * strlen_user includes \0. If returns 0, it faulted, so we set size to + * 1 (\0 only). + */ +#undef __string_from_user +#define __string_from_user(_item, _src) \ + __event_len += __dynamic_len[__dynamic_len_idx++] = \ + max_t(size_t, lttng_strlen_user_inatomic(_src), 1); -#undef DEFINE_EVENT -#define DEFINE_EVENT(template, name, proto, args) +#undef TP_PROTO +#define TP_PROTO(args...) args -#undef DEFINE_EVENT_PRINT -#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ - DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args)) +#undef TP_STRUCT__entry +#define TP_STRUCT__entry(args...) args + +#undef DECLARE_EVENT_CLASS +#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \ +static inline size_t __event_get_size__##_name(size_t *__dynamic_len, _proto) \ +{ \ + size_t __event_len = 0; \ + unsigned int __dynamic_len_idx = 0; \ + \ + if (0) \ + (void) __dynamic_len_idx; /* don't warn if unused */ \ + _tstruct \ + return __event_len; \ +} #include TRACE_INCLUDE(TRACE_INCLUDE_FILE) /* - * Stage 3 of the trace events. + * Stage 7 of the trace events. * - * Create the probe function : call even size calculation and write event data - * into the buffer. + * Create static inline function that calculates event payload alignment. */ -#undef __entry -#define __entry field +#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */ -#undef TP_printk -#define TP_printk(fmt, args...) fmt "\n", args +/* Named field types must be defined in lttng-types.h */ -#undef __get_dynamic_array -#define __get_dynamic_array(field) \ - ((void *)__entry + (__entry->__data_loc_##field & 0xffff)) +#undef __field_full +#define __field_full(_type, _item, _order, _base) \ + __event_align = max_t(size_t, __event_align, lttng_alignof(_type)); -#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 __array_enc_ext +#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding) \ + __event_align = max_t(size_t, __event_align, lttng_alignof(_type)); -#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 __dynamic_array_enc_ext +#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding)\ + __event_align = max_t(size_t, __event_align, lttng_alignof(u32)); \ + __event_align = max_t(size_t, __event_align, lttng_alignof(_type)); -#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 __dynamic_array_enc_ext_2 +#define __dynamic_array_enc_ext_2(_type, _item, _length1, _length2, _order, _base, _encoding)\ + __dynamic_array_enc_ext(_type, _item, _length1 + _length2, _order, _base, _encoding) -#undef __field -#define __field(type, item) __field_ext(type, item, FILTER_OTHER) +#undef __string +#define __string(_item, _src) -#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 __string_from_user +#define __string_from_user(_item, _src) -#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 TP_PROTO +#define TP_PROTO(args...) args -#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(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; \ +#define DECLARE_EVENT_CLASS(_name, _proto, _args, _tstruct, _assign, _print) \ +static inline size_t __event_get_align__##_name(_proto) \ +{ \ + size_t __event_align = 1; \ + _tstruct \ + return __event_align; \ } -#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. + * Stage 8 of the trace events. + * + * Create structure declaration that allows the "assign" macros to access the + * field types. */ -#undef __entry -#define __entry entry +#include "lttng-events-reset.h" /* Reset all macros within TRACE_EVENT */ -#undef __field -#define __field(type, item) +/* Named field types must be defined in lttng-types.h */ -#undef __field_ext -#define __field_ext(type, item, filter_type) +#undef __field_full +#define __field_full(_type, _item, _order, _base) _type _item; -#undef __array -#define __array(type, item, len) +#undef __array_enc_ext +#define __array_enc_ext(_type, _item, _length, _order, _base, _encoding) \ + _type _item; -#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 __dynamic_array_enc_ext +#define __dynamic_array_enc_ext(_type, _item, _length, _order, _base, _encoding)\ + _type _item; + +#undef __dynamic_array_enc_ext_2 +#define __dynamic_array_enc_ext_2(_type, _item, _length1, _length2, _order, _base, _encoding)\ + __dynamic_array_enc_ext(_type, _item, _length1 + _length2, _order, _base, _encoding) #undef __string -#define __string(item, src) __dynamic_array(char, item, strlen(src) + 1) +#define __string(_item, _src) char _item; -#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 __string_from_user +#define __string_from_user(_item, _src) \ + __string(_item, _src) -#undef DEFINE_EVENT -#define DEFINE_EVENT(template, name, proto, args) +#undef TP_STRUCT__entry +#define TP_STRUCT__entry(args...) args -#undef DEFINE_EVENT_PRINT -#define DEFINE_EVENT_PRINT(template, name, proto, args, print) \ - DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(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 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); + * Stage 9 of the trace events. * - * { ; } <-- Here we assign the entries by the __field and - * __array macros. - * - * 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_