Skip to contentSkip to conversation

tracing/events: provide string with undefined size support

RFC PATCH Superseded Frederic Weisbecker 3 participants 8 messages Apr 15, 2009 – Apr 16, 2009

Subsystems (2)

v1 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

RFC PATCH 1/2 tracing/events: provide string with undefined size support

Impact: less memory usage for tracing

This patch provides the support for dynamic size strings on event tracing.

The key concept is to use a structure with an ending char array field of undefined size and use such ability to allocate the minimal size on the ring buffer to make the entry fit inside as opposite to a fixed length strings with upper bound.

This patch provides two new macros:

-__ending_string(name)

This one declares the string to the structure inside TP_STRUCT__entry. Only the name is needed.
Two constraints: only one __ending_string() per TRACE_EVENT can be added and it must be the last field to be declared. Hence the __ending prefix.

- open_string_assign(call, dst, src)

This one does the copy inside TP__fast_assign() of the source string to the destination. The name of the tracepoint (call) must be provided for now. Hopefully I will find a solution to avoid it later.

Two constraint: can be used only once and always on the beginning because it needs to manage the ring buffer reservation by itself. Hence the open prefix.

How does it works?

A new has_ending_string field has been added to struct ftrace_event_call and is false by default.
Once a TRACE_EVENT uses an __ending_string field, it is set to 1.

Until now, the ring buffer reservation was done in ftrace_raw_event_##call(). It is still the case if we don't have an __ending_string() field. If we have one, open_string_assign() will manage it itself to allocate the appropriate size, depending of the size of the string to be copied for each trace.

The choice between the usual static allocation and the new dynamic one depends on the "has_ending_string" value.

It also support filtering because these strings behave essentially like usual fixed length string.

---
 include/linux/ftrace_event.h |    1 +
 include/trace/ftrace.h       |   62 ++++++++++++++++++++++++++++++++++++-----
 2 files changed, 55 insertions(+), 8 deletions(-)
include/linux/ftrace_event.h +1 -0
index 75f3ac0..b49bfbf 100644
@@ -100,6 +100,7 @@ struct ftrace_event_call {
 	int			n_preds;
 	struct filter_pred	**preds;
 	void			*mod;
+	bool			has_ending_string;
 
 #ifdef CONFIG_EVENT_PROFILE
 	atomic_t	profile_count;
include/trace/ftrace.h +54 -8

104 lines not on this page · raw message

Signature · 1 line
1.6.1
#1 lore raw

RFC PATCH 2/2 tracing/lock: provide lock_acquired event support for dynamic size string

Now that we can support the dynamic sized string, make the lock tracing able to use it, making it safe against modules removal and consuming the right amount of memory needed for each lock name

---
 include/trace/events/lockdep.h |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)
include/trace/events/lockdep.h +2 -2
index 45e326b..48356b7 100644
@@ -38,12 +38,12 @@ TRACE_EVENT(lock_acquired,
 	TP_ARGS(lock, ip, waittime),
 
 	TP_STRUCT__entry(
-		__field(const char *, name)
 		__field(unsigned long, wait_usec)
 		__field(unsigned long, wait_nsec_rem)
+		__ending_string(name)
 	),
 	TP_fast_assign(
-		__entry->name = lock->name;
+		open_string_assign(lock_acquired, name, lock->name);
 		__entry->wait_nsec_rem = do_div(waittime, NSEC_PER_USEC);
 		__entry->wait_usec = (unsigned long) waittime;
 	),
Signature · 1 line
1.6.1
#2 lore raw
In reply to Frederic Weisbecker
Quoted 5 lines · Frederic Weisbecker

Impact: less memory usage for tracing

This patch provides the support for dynamic size strings on event tracing.

blktrace TRACE_EVENTs need this too. :)

Quoted 16 lines

The key concept is to use a structure with an ending char array field of undefined size and use such ability to allocate the minimal size on the ring buffer to make the entry fit inside as opposite to a fixed length strings with upper bound.

This patch provides two new macros:

-__ending_string(name)

This one declares the string to the structure inside TP_STRUCT__entry. Only the name is needed.
Two constraints: only one __ending_string() per TRACE_EVENT can be added and it must be the last field to be declared. Hence the __ending prefix.

- open_string_assign(call, dst, src)

Quoted 9 lines

This one does the copy inside TP__fast_assign() of the source string to the destination. The name of the tracepoint (call) must be provided for now. Hopefully I will find a solution to avoid it later.

Two constraint: can be used only once and always on the beginning because it needs to manage the ring buffer reservation by itself. Hence the open prefix.

How does it works?

I'll let you know if I meet any problem when using this in blktrace TRACE_EVENTs.

Quoted 20 lines

A new has_ending_string field has been added to struct ftrace_event_call and is false by default.
Once a TRACE_EVENT uses an __ending_string field, it is set to 1.

Until now, the ring buffer reservation was done in ftrace_raw_event_##call(). It is still the case if we don't have an __ending_string() field. If we have one, open_string_assign() will manage it itself to allocate the appropriate size, depending of the size of the string to be copied for each trace.

The choice between the usual static allocation and the new dynamic one depends on the "has_ending_string" value.

It also support filtering because these strings behave essentially like usual fixed length string.

---
 include/linux/ftrace_event.h |    1 +
 include/trace/ftrace.h       |   62 ++++++++++++++++++++++++++++++++++++-----
 2 files changed, 55 insertions(+), 8 deletions(-)

...

Quoted 4 lines
include/trace/ftrace.h +4 -0
+/*
+ * If we have and ending undefined string size, then the size of
+ * the entry is dynamic. In such case we override the ring buffer
+ * reservation to manage it ourselves with our dynamic string size.

include/trace/ftrace.h __attribute__((section("_ftrace_events"))) event_##call = { \ · line 452

Quoted 10 lines
include/trace/ftrace.h +10 -0
+ */
+#undef open_string_assign
+#define open_string_assign(call, dst, src)				       \
+	event = trace_current_buffer_lock_reserve(			       \
+			event_##call.id,				       \
+			sizeof(struct ftrace_raw_##call) + strlen(src) + 1,    \
+			irq_flags, pc);					       \
+	if (!event)							       \
+		return;							       \
+	entry	= ring_buffer_event_data(event);			       \

small nits, below is better since we have only one assignment:

	entry = ring_buffer_event_data(event);
Quoted 23 lines
include/trace/ftrace.h +4 -6
+	strcpy(entry->dst, src);
+
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, assign, print)		\
 _TRACE_PROFILE(call, PARAMS(proto), PARAMS(args))			\
@@ -418,20 +461,23 @@ static struct ftrace_event_call event_##call;				\
 static void ftrace_raw_event_##call(proto)				\
 {									\
 	struct ftrace_event_call *call = &event_##call;			\
-	struct ring_buffer_event *event;				\
-	struct ftrace_raw_##call *entry;				\
+	struct ring_buffer_event *event = NULL;				\
+	struct ftrace_raw_##call *entry = NULL;				\
 	unsigned long irq_flags;					\
 	int pc;								\
 									\
 	local_save_flags(irq_flags);					\
 	pc = preempt_count();						\
 									\
-	event = trace_current_buffer_lock_reserve(event_##call.id,	\
-				  sizeof(struct ftrace_raw_##call),	\
-				  irq_flags, pc);			\
-	if (!event)							\

include/trace/ftrace.h static struct ftrace_event_call event_##call; \ · line 479

Quoted 10 lines
include/trace/ftrace.h +8 -2
-		return;							\
-	entry	= ring_buffer_event_data(event);			\
+	if (!call->has_ending_string) {					\
+		event = trace_current_buffer_lock_reserve(		\
+				event_##call.id,			\
+				sizeof(struct ftrace_raw_##call),	\
+				irq_flags, pc);				\
+		if (!event)						\
+			return;						\
+		entry	= ring_buffer_event_data(event);		\

ditoo

Quoted 4 lines
include/trace/ftrace.h +1 -0
+	}								\
 									\
 	assign;								\
 									\
#3 lore raw
Quoted 8 lines · Li Zefan
Quoted 5 lines · Frederic Weisbecker

Impact: less memory usage for tracing

This patch provides the support for dynamic size strings on event tracing.

blktrace TRACE_EVENTs need this too. :)

:-)

Quoted 20 lines
Quoted 20 lines

The key concept is to use a structure with an ending char array field of undefined size and use such ability to allocate the minimal size on the ring buffer to make the entry fit inside as opposite to a fixed length strings with upper bound.

This patch provides two new macros:

-__ending_string(name)

This one declares the string to the structure inside TP_STRUCT__entry. Only the name is needed.
Two constraints: only one __ending_string() per TRACE_EVENT can be added and it must be the last field to be declared. Hence the __ending prefix.

- open_string_assign(call, dst, src)

This one does the copy inside TP__fast_assign() of the source string to the destination. The name of the tracepoint (call) must be provided for now. Hopefully I will find a solution to avoid it later.

Quoted 8 lines
Quoted 5 lines

Two constraint: can be used only once and always on the beginning because it needs to manage the ring buffer reservation by itself. Hence the open prefix.

How does it works?

I'll let you know if I meet any problem when using this in blktrace TRACE_EVENTs.

Thanks Li!
Just wait a bit while I integrate Steven's idea, a v2 should come soon :)

Quoted 40 lines
Quoted 20 lines

A new has_ending_string field has been added to struct ftrace_event_call and is false by default.
Once a TRACE_EVENT uses an __ending_string field, it is set to 1.

Until now, the ring buffer reservation was done in ftrace_raw_event_##call(). It is still the case if we don't have an __ending_string() field. If we have one, open_string_assign() will manage it itself to allocate the appropriate size, depending of the size of the string to be copied for each trace.

The choice between the usual static allocation and the new dynamic one depends on the "has_ending_string" value.

It also support filtering because these strings behave essentially like usual fixed length string.

---
 include/linux/ftrace_event.h |    1 +
 include/trace/ftrace.h       |   62 ++++++++++++++++++++++++++++++++++++-----
 2 files changed, 55 insertions(+), 8 deletions(-)

...

Quoted 4 lines
include/trace/ftrace.h +4 -0
+/*
+ * If we have and ending undefined string size, then the size of
+ * the entry is dynamic. In such case we override the ring buffer
+ * reservation to manage it ourselves with our dynamic string size.

include/trace/ftrace.h __attribute__((section("_ftrace_events"))) event_##call = { \ · line 452

Quoted 10 lines
include/trace/ftrace.h +10 -0
+ */
+#undef open_string_assign
+#define open_string_assign(call, dst, src)				       \
+	event = trace_current_buffer_lock_reserve(			       \
+			event_##call.id,				       \
+			sizeof(struct ftrace_raw_##call) + strlen(src) + 1,    \
+			irq_flags, pc);					       \
+	if (!event)							       \
+		return;							       \
+	entry	= ring_buffer_event_data(event);			       \

small nits, below is better since we have only one assignment:

Quoted 1 line
	entry = ring_buffer_event_data(event);

Hm, I don't understand what you are suggesting.

Frederic.

Quoted 41 lines
Quoted 23 lines
include/trace/ftrace.h +4 -6
+	strcpy(entry->dst, src);
+
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, assign, print)		\
 _TRACE_PROFILE(call, PARAMS(proto), PARAMS(args))			\
@@ -418,20 +461,23 @@ static struct ftrace_event_call event_##call;				\
 static void ftrace_raw_event_##call(proto)				\
 {									\
 	struct ftrace_event_call *call = &event_##call;			\
-	struct ring_buffer_event *event;				\
-	struct ftrace_raw_##call *entry;				\
+	struct ring_buffer_event *event = NULL;				\
+	struct ftrace_raw_##call *entry = NULL;				\
 	unsigned long irq_flags;					\
 	int pc;								\
 									\
 	local_save_flags(irq_flags);					\
 	pc = preempt_count();						\
 									\
-	event = trace_current_buffer_lock_reserve(event_##call.id,	\
-				  sizeof(struct ftrace_raw_##call),	\
-				  irq_flags, pc);			\
-	if (!event)							\

include/trace/ftrace.h static struct ftrace_event_call event_##call; \ · line 479

Quoted 10 lines
include/trace/ftrace.h +8 -2
-		return;							\
-	entry	= ring_buffer_event_data(event);			\
+	if (!call->has_ending_string) {					\
+		event = trace_current_buffer_lock_reserve(		\
+				event_##call.id,			\
+				sizeof(struct ftrace_raw_##call),	\
+				irq_flags, pc);				\
+		if (!event)						\
+			return;						\
+		entry	= ring_buffer_event_data(event);		\

ditoo

Quoted 4 lines
include/trace/ftrace.h +1 -0
+	}								\
 									\
 	assign;								\
 									\
#4 lore raw
Quoted 9 lines
Quoted 4 lines

Review

Quoted 1 line
(quoted diff) +1 -0
+	entry	= ring_buffer_event_data(event);			       \

small nits, below is better since we have only one assignment:

	entry = ring_buffer_event_data(event);

Hm, I don't understand what you are suggesting.

I meant just add a ' ' before '=' instead of a tab:

entry = ring_buffer_event_data(event);
entry = ring_buffer_event_data(event);

since we don't need to align with other assignment statement.

but this is just a trivial issue. :)

--
Zefan

#5 lore raw
Quoted 10 lines · Li Zefan
Quoted 9 lines
Quoted 4 lines

Review

Quoted 1 line
(quoted diff) +1 -0
+	entry	= ring_buffer_event_data(event);			       \

small nits, below is better since we have only one assignment:

	entry = ring_buffer_event_data(event);

Hm, I don't understand what you are suggesting.

Quoted 8 lines

I meant just add a ' ' before '=' instead of a tab:

entry = ring_buffer_event_data(event);
entry = ring_buffer_event_data(event);

since we don't need to align with other assignment statement.

but this is just a trivial issue. :)

Ah ok :)
Will fix it (unless I remove this part to address Steven's comment.

Thanks.

Quoted 2 lines

--
Zefan

maintainer
#6 lore raw
In reply to Frederic Weisbecker
Quoted 39 lines · Frederic Weisbecker

Impact: less memory usage for tracing

This patch provides the support for dynamic size strings on event tracing.

The key concept is to use a structure with an ending char array field of undefined size and use such ability to allocate the minimal size on the ring buffer to make the entry fit inside as opposite to a fixed length strings with upper bound.

This patch provides two new macros:

-__ending_string(name)

This one declares the string to the structure inside TP_STRUCT__entry. Only the name is needed.
Two constraints: only one __ending_string() per TRACE_EVENT can be added and it must be the last field to be declared. Hence the __ending prefix.

- open_string_assign(call, dst, src)

This one does the copy inside TP__fast_assign() of the source string to the destination. The name of the tracepoint (call) must be provided for now. Hopefully I will find a solution to avoid it later.

Two constraint: can be used only once and always on the beginning because it needs to manage the ring buffer reservation by itself. Hence the open prefix.

How does it works?

A new has_ending_string field has been added to struct ftrace_event_call and is false by default.
Once a TRACE_EVENT uses an __ending_string field, it is set to 1.

Until now, the ring buffer reservation was done in ftrace_raw_event_##call(). It is still the case if we don't have an __ending_string() field. If we have one, open_string_assign() will manage it itself to allocate the appropriate size, depending of the size of the string to be copied for each trace.

Quoted 5 lines

The choice between the usual static allocation and the new dynamic one depends on the "has_ending_string" value.

It also support filtering because these strings behave essentially like usual fixed length string.

And I thought I was the only one that could master CPP wackiness ;-)

BTW, I was confused on IRC, because I was thinking this was printf like, but no, we only need to be concerned about a string.

But I have another idea:

Quoted 122 lines
---
 include/linux/ftrace_event.h |    1 +
 include/trace/ftrace.h       |   62 ++++++++++++++++++++++++++++++++++++-----
 2 files changed, 55 insertions(+), 8 deletions(-)
include/linux/ftrace_event.h +1 -0
index 75f3ac0..b49bfbf 100644
@@ -100,6 +100,7 @@ struct ftrace_event_call {
 	int			n_preds;
 	struct filter_pred	**preds;
 	void			*mod;
+	bool			has_ending_string;
 
 #ifdef CONFIG_EVENT_PROFILE
 	atomic_t	profile_count;
include/trace/ftrace.h +47 -8
index 60c5323..8ea750e 100644
@@ -27,6 +27,9 @@
 #undef __field
 #define __field(type, item)		type	item;
 
+#undef __ending_string
+#define __ending_string(item)			char	item[];
+
 #undef TP_STRUCT__entry
 #define TP_STRUCT__entry(args...) args
 
@@ -146,12 +149,23 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags)	\
 	if (!ret)							\
 		return 0;
 
+#undef __ending_string
+#define __ending_string(item)						      \
+	ret = trace_seq_printf(s, "\tfield: char " #item "[];\t"	      \
+			       "offset:%u;\n",				      \
+			       (unsigned int)offsetof(typeof(field), item));   \
+	if (!ret)							      \
+		return 0;
+
 #undef __entry
 #define __entry REC
 
 #undef TP_printk
 #define TP_printk(fmt, args...) "%s, %s\n", #fmt, __stringify(args)
 
+#undef open_string_assign
+#define open_string_assign(call, dst, src)	strcpy(__entry->dst, src)
+
 #undef TP_fast_assign
 #define TP_fast_assign(args...) args
 
@@ -189,6 +203,19 @@ ftrace_format_##call(struct trace_seq *s)				\
 	if (ret)							\
 		return ret;
 
+/*
+ * We choose a size of MAX_FILTER_STR_VAL, then we behave like
+ * a usual string with the maximum size to keep being filterable.
+ */
+#undef __ending_string
+#define __ending_string(item)						\
+	ret = trace_define_field(event_call, "char []", #item,		\
+				 offsetof(typeof(field), item),		\
+				 MAX_FILTER_STR_VAL);			\
+	if (ret)							\
+		return ret;						\
+	event_call->has_ending_string = true;
+
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, func, print)		\
 int									\
@@ -409,6 +436,22 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 #undef __entry
 #define __entry entry
 
+/*
+ * If we have and ending undefined string size, then the size of
+ * the entry is dynamic. In such case we override the ring buffer
+ * reservation to manage it ourselves with our dynamic string size.
+ */
+#undef open_string_assign
+#define open_string_assign(call, dst, src)				       \
+	event = trace_current_buffer_lock_reserve(			       \
+			event_##call.id,				       \
+			sizeof(struct ftrace_raw_##call) + strlen(src) + 1,    \
+			irq_flags, pc);					       \
+	if (!event)							       \
+		return;							       \
+	entry	= ring_buffer_event_data(event);			       \
+	strcpy(entry->dst, src);
+
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, assign, print)		\
 _TRACE_PROFILE(call, PARAMS(proto), PARAMS(args))			\
@@ -418,20 +461,23 @@ static struct ftrace_event_call event_##call;				\
 static void ftrace_raw_event_##call(proto)				\
 {									\
 	struct ftrace_event_call *call = &event_##call;			\
-	struct ring_buffer_event *event;				\
-	struct ftrace_raw_##call *entry;				\
+	struct ring_buffer_event *event = NULL;				\
+	struct ftrace_raw_##call *entry = NULL;				\
 	unsigned long irq_flags;					\
 	int pc;								\
 									\
 	local_save_flags(irq_flags);					\
 	pc = preempt_count();						\
 									\
-	event = trace_current_buffer_lock_reserve(event_##call.id,	\
-				  sizeof(struct ftrace_raw_##call),	\
-				  irq_flags, pc);			\
-	if (!event)							\
-		return;							\
-	entry	= ring_buffer_event_data(event);			\
+	if (!call->has_ending_string) {					\
+		event = trace_current_buffer_lock_reserve(		\

include/trace/ftrace.h static struct ftrace_event_call event_##call; \ · line 483

Quoted 10 lines
include/trace/ftrace.h +7 -0
+				event_##call.id,			\
+				sizeof(struct ftrace_raw_##call),	\
+				irq_flags, pc);				\
+		if (!event)						\
+			return;						\
+		entry	= ring_buffer_event_data(event);		\
+	}								\
 									\
 	assign;								\
 									\

We can get rid of the has_ending_string and open_string_assign and have this:

        TP_STRUCT__entry(
                __field(unsigned long, wait_usec)
                __field(unsigned long, wait_nsec_rem)
                __ending_string(name)
        ),
        TP_fast_assign(
                __entry->wait_nsec_rem = do_div(waittime, NSEC_PER_USEC);
                __entry->wait_usec = (unsigned long) waittime;
                strcpy(__entry->name, lock->name);
        ),

Then we could do the following in the print the assign:

#undef __field
#define __field(a,b)
#undef __array
#define __array(a,b,c)
#undef __ending_sting
#define __ending_string(name) __str_size__ += strlen(name) + 1;

#define TRACE_EVENT(call, proto, args, tstruct, assign, print) static void ftrace_raw_event_##call(proto)

{
	int __str_size__ = 0;

	tstruct

	event = trace_current_buffer_lock_reserve(event_##call.id,
				sizeof(struct ftrace_raw_##call) +
				__str_size__,
				irq_flags, pc)
	if (!event)
		return;

	entry = ring_buffer_event_data(event);

	assign
}

Yes, I did not add other declarations nor the backslashes for the macro, but you get what I'm doing, right?

-- Steve

#7 lore raw
Quoted 42 lines · Steven Rostedt
Quoted 39 lines · Frederic Weisbecker

Impact: less memory usage for tracing

This patch provides the support for dynamic size strings on event tracing.

The key concept is to use a structure with an ending char array field of undefined size and use such ability to allocate the minimal size on the ring buffer to make the entry fit inside as opposite to a fixed length strings with upper bound.

This patch provides two new macros:

-__ending_string(name)

This one declares the string to the structure inside TP_STRUCT__entry. Only the name is needed.
Two constraints: only one __ending_string() per TRACE_EVENT can be added and it must be the last field to be declared. Hence the __ending prefix.

- open_string_assign(call, dst, src)

This one does the copy inside TP__fast_assign() of the source string to the destination. The name of the tracepoint (call) must be provided for now. Hopefully I will find a solution to avoid it later.

Two constraint: can be used only once and always on the beginning because it needs to manage the ring buffer reservation by itself. Hence the open prefix.

How does it works?

A new has_ending_string field has been added to struct ftrace_event_call and is false by default.
Once a TRACE_EVENT uses an __ending_string field, it is set to 1.

Until now, the ring buffer reservation was done in ftrace_raw_event_##call(). It is still the case if we don't have an __ending_string() field. If we have one, open_string_assign() will manage it itself to allocate the appropriate size, depending of the size of the string to be copied for each trace.

Quoted 7 lines
Quoted 5 lines

The choice between the usual static allocation and the new dynamic one depends on the "has_ending_string" value.

It also support filtering because these strings behave essentially like usual fixed length string.

And I thought I was the only one that could master CPP wackiness ;-)

:-)

Quoted 186 lines

BTW, I was confused on IRC, because I was thinking this was printf like, but no, we only need to be concerned about a string.

But I have another idea:

Quoted 122 lines
---
 include/linux/ftrace_event.h |    1 +
 include/trace/ftrace.h       |   62 ++++++++++++++++++++++++++++++++++++-----
 2 files changed, 55 insertions(+), 8 deletions(-)
include/linux/ftrace_event.h +1 -0
index 75f3ac0..b49bfbf 100644
@@ -100,6 +100,7 @@ struct ftrace_event_call {
 	int			n_preds;
 	struct filter_pred	**preds;
 	void			*mod;
+	bool			has_ending_string;
 
 #ifdef CONFIG_EVENT_PROFILE
 	atomic_t	profile_count;
include/trace/ftrace.h +47 -8
index 60c5323..8ea750e 100644
@@ -27,6 +27,9 @@
 #undef __field
 #define __field(type, item)		type	item;
 
+#undef __ending_string
+#define __ending_string(item)			char	item[];
+
 #undef TP_STRUCT__entry
 #define TP_STRUCT__entry(args...) args
 
@@ -146,12 +149,23 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags)	\
 	if (!ret)							\
 		return 0;
 
+#undef __ending_string
+#define __ending_string(item)						      \
+	ret = trace_seq_printf(s, "\tfield: char " #item "[];\t"	      \
+			       "offset:%u;\n",				      \
+			       (unsigned int)offsetof(typeof(field), item));   \
+	if (!ret)							      \
+		return 0;
+
 #undef __entry
 #define __entry REC
 
 #undef TP_printk
 #define TP_printk(fmt, args...) "%s, %s\n", #fmt, __stringify(args)
 
+#undef open_string_assign
+#define open_string_assign(call, dst, src)	strcpy(__entry->dst, src)
+
 #undef TP_fast_assign
 #define TP_fast_assign(args...) args
 
@@ -189,6 +203,19 @@ ftrace_format_##call(struct trace_seq *s)				\
 	if (ret)							\
 		return ret;
 
+/*
+ * We choose a size of MAX_FILTER_STR_VAL, then we behave like
+ * a usual string with the maximum size to keep being filterable.
+ */
+#undef __ending_string
+#define __ending_string(item)						\
+	ret = trace_define_field(event_call, "char []", #item,		\
+				 offsetof(typeof(field), item),		\
+				 MAX_FILTER_STR_VAL);			\
+	if (ret)							\
+		return ret;						\
+	event_call->has_ending_string = true;
+
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, func, print)		\
 int									\
@@ -409,6 +436,22 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 #undef __entry
 #define __entry entry
 
+/*
+ * If we have and ending undefined string size, then the size of
+ * the entry is dynamic. In such case we override the ring buffer
+ * reservation to manage it ourselves with our dynamic string size.
+ */
+#undef open_string_assign
+#define open_string_assign(call, dst, src)				       \
+	event = trace_current_buffer_lock_reserve(			       \
+			event_##call.id,				       \
+			sizeof(struct ftrace_raw_##call) + strlen(src) + 1,    \
+			irq_flags, pc);					       \
+	if (!event)							       \
+		return;							       \
+	entry	= ring_buffer_event_data(event);			       \
+	strcpy(entry->dst, src);
+
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, assign, print)		\
 _TRACE_PROFILE(call, PARAMS(proto), PARAMS(args))			\
@@ -418,20 +461,23 @@ static struct ftrace_event_call event_##call;				\
 static void ftrace_raw_event_##call(proto)				\
 {									\
 	struct ftrace_event_call *call = &event_##call;			\
-	struct ring_buffer_event *event;				\
-	struct ftrace_raw_##call *entry;				\
+	struct ring_buffer_event *event = NULL;				\
+	struct ftrace_raw_##call *entry = NULL;				\
 	unsigned long irq_flags;					\
 	int pc;								\
 									\
 	local_save_flags(irq_flags);					\
 	pc = preempt_count();						\
 									\
-	event = trace_current_buffer_lock_reserve(event_##call.id,	\
-				  sizeof(struct ftrace_raw_##call),	\
-				  irq_flags, pc);			\
-	if (!event)							\
-		return;							\
-	entry	= ring_buffer_event_data(event);			\
+	if (!call->has_ending_string) {					\
+		event = trace_current_buffer_lock_reserve(		\

include/trace/ftrace.h static struct ftrace_event_call event_##call; \ · line 483

Quoted 10 lines
include/trace/ftrace.h +7 -0
+				event_##call.id,			\
+				sizeof(struct ftrace_raw_##call),	\
+				irq_flags, pc);				\
+		if (!event)						\
+			return;						\
+		entry	= ring_buffer_event_data(event);		\
+	}								\
 									\
 	assign;								\
 									\

We can get rid of the has_ending_string and open_string_assign and have this:

        TP_STRUCT__entry(
                __field(unsigned long, wait_usec)
                __field(unsigned long, wait_nsec_rem)
                __ending_string(name)
        ),
        TP_fast_assign(
                __entry->wait_nsec_rem = do_div(waittime, NSEC_PER_USEC);
                __entry->wait_usec = (unsigned long) waittime;
                strcpy(__entry->name, lock->name);
        ),

Then we could do the following in the print the assign:

#undef __field
#define __field(a,b)
#undef __array
#define __array(a,b,c)
#undef __ending_sting
#define __ending_string(name) __str_size__ += strlen(name) + 1;

#define TRACE_EVENT(call, proto, args, tstruct, assign, print) static void ftrace_raw_event_##call(proto)

{
	int __str_size__ = 0;

	tstruct

	event = trace_current_buffer_lock_reserve(event_##call.id,
				sizeof(struct ftrace_raw_##call) +
				__str_size__,
				irq_flags, pc)
	if (!event)
		return;

	entry = ring_buffer_event_data(event);

	assign
}
Quoted 2 lines

Yes, I did not add other declarations nor the backslashes for the macro, but you get what I'm doing, right?

Oh!
I'm surprised, this is much more proper this way and also so obvious too!

Thanks a lot, I will integrate this simplification in a v2.

Quoted 2 lines

-- Steve