[RFC PATCH] Trace: use unsigned long long in trace print frames

[RFC PATCH] Trace: use unsigned long long in trace print frames

[liubo]

While adding tracepoint for btrfs, I got a problem:

btrfs uses some macros with "ULL" type, but tracepoint's macros,
__print_[flags,symbols](), only have "unsigned long", so on 32bit box
there will be 64->32 truncate WARNINGs when compiling.

Here I'm inclined to make the replacement to clear those WARNINGs.

Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
---
 include/linux/ftrace_event.h |    7 ++++---
 kernel/trace/trace_output.c  |   10 +++++-----
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 22b32af..b52f2c5 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -12,15 +12,16 @@ struct tracer;
 struct dentry;
 
 struct trace_print_flags {
-	unsigned long		mask;
+	unsigned long long	mask;
 	const char		*name;
 };
 
 const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
-				   unsigned long flags,
+				   unsigned long long flags,
 				   const struct trace_print_flags *flag_array);
 
-const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
+const char *ftrace_print_symbols_seq(struct trace_seq *p,
+				     unsigned long long val,
 				     const struct trace_print_flags *symbol_array);
 
 const char *ftrace_print_hex_seq(struct trace_seq *p,
diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
index 456be90..97ba902 100644
--- a/kernel/trace/trace_output.c
+++ b/kernel/trace/trace_output.c
@@ -294,10 +294,10 @@ int trace_seq_path(struct trace_seq *s, struct path *path)
 
 const char *
 ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
-		       unsigned long flags,
+		       unsigned long long flags,
 		       const struct trace_print_flags *flag_array)
 {
-	unsigned long mask;
+	unsigned long long mask;
 	const char *str;
 	const char *ret = p->buffer + p->len;
 	int i;
@@ -319,7 +319,7 @@ ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
 	if (flags) {
 		if (p->len && delim)
 			trace_seq_puts(p, delim);
-		trace_seq_printf(p, "0x%lx", flags);
+		trace_seq_printf(p, "0x%llx", flags);
 	}
 
 	trace_seq_putc(p, 0);
@@ -329,7 +329,7 @@ ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
 EXPORT_SYMBOL(ftrace_print_flags_seq);
 
 const char *
-ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
+ftrace_print_symbols_seq(struct trace_seq *p, unsigned long long val,
 			 const struct trace_print_flags *symbol_array)
 {
 	int i;
@@ -345,7 +345,7 @@ ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
 	}
 
 	if (!p->len)
-		trace_seq_printf(p, "0x%lx", val);
+		trace_seq_printf(p, "0x%llx", val);
 		
 	trace_seq_putc(p, 0);
 
-- 
1.6.5.2

Re: [RFC PATCH] Trace: use unsigned long long in trace print frames

[Steven Rostedt]

On Fri, 2011-04-01 at 14:42 +0800, liubo wrote:
> While adding tracepoint for btrfs, I got a problem:
> 
> btrfs uses some macros with "ULL" type, but tracepoint's macros,
> __print_[flags,symbols](), only have "unsigned long", so on 32bit box
> there will be 64->32 truncate WARNINGs when compiling.
> 
> Here I'm inclined to make the replacement to clear those WARNINGs.

Hmm, I don't like this. unsigned long is a natural word for
architectures, I don't want to have 32 bit suffer because one user is
doing something with ULL.

A better solution is to add a trace_print_flags_u64 or something, that
can be used for cases that u64 is needed. For archs were sizeof(long) ==
sizeof(u64) we can have the two macros/structs be the same.

-- Steve

Re: [RFC PATCH] Trace: use unsigned long long in trace print frames

[liubo]

On 04/01/2011 09:49 PM, Steven Rostedt wrote:
> On Fri, 2011-04-01 at 14:42 +0800, liubo wrote:
>> While adding tracepoint for btrfs, I got a problem:
>>
>> btrfs uses some macros with "ULL" type, but tracepoint's macros,
>> __print_[flags,symbols](), only have "unsigned long", so on 32bit box
>> there will be 64->32 truncate WARNINGs when compiling.
>>
>> Here I'm inclined to make the replacement to clear those WARNINGs.
> 
> Hmm, I don't like this. unsigned long is a natural word for
> architectures, I don't want to have 32 bit suffer because one user is
> doing something with ULL.
> 
> A better solution is to add a trace_print_flags_u64 or something, that
> can be used for cases that u64 is needed. For archs were sizeof(long) ==
> sizeof(u64) we can have the two macros/structs be the same.
> 

All right, a u64 specific one is also in my mind. :)

thanks,
liubo

> -- Steve
> 
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-btrfs" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> 

[PATCH] Trace: add __print_symbolic_u64 to avoid warnings on 32bit machine

[liubo]

Btrfs has some "ULL" macros, and when these macros are passed to tracepoints'
__print_symbolic(), there will be 64->32 truncate WARNINGS during compiling
on 32bit box.

Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
---
 include/linux/ftrace_event.h |   12 ++++++++++++
 include/trace/events/btrfs.h |    4 ++--
 include/trace/ftrace.h       |   13 +++++++++++++
 kernel/trace/trace_output.c  |   27 +++++++++++++++++++++++++++
 4 files changed, 54 insertions(+), 2 deletions(-)

diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 22b32af..6b2e245 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -16,6 +16,11 @@ struct trace_print_flags {
 	const char		*name;
 };
 
+struct trace_print_flags_u64 {
+	unsigned long long	mask;
+	const char		*name;
+};
+
 const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
 				   unsigned long flags,
 				   const struct trace_print_flags *flag_array);
@@ -23,6 +28,13 @@ const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
 const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
 				     const struct trace_print_flags *symbol_array);
 
+#if BITS_PER_LONG == 32
+const char *ftrace_print_symbols_seq_u64(struct trace_seq *p,
+					 unsigned long long val,
+					 const struct trace_print_flags_u64
+								 *symbol_array);
+#endif
+
 const char *ftrace_print_hex_seq(struct trace_seq *p,
 				 const unsigned char *buf, int len);
 
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index f445cff..4114129 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -28,7 +28,7 @@ struct extent_buffer;
 		{ BTRFS_SHARED_DATA_REF_KEY, 	"SHARED_DATA_REF" })
 
 #define __show_root_type(obj)						\
-	__print_symbolic(obj,						\
+	__print_symbolic_u64(obj,					\
 		{ BTRFS_ROOT_TREE_OBJECTID, 	"ROOT_TREE"	},	\
 		{ BTRFS_EXTENT_TREE_OBJECTID, 	"EXTENT_TREE"	},	\
 		{ BTRFS_CHUNK_TREE_OBJECTID, 	"CHUNK_TREE"	},	\
@@ -125,7 +125,7 @@ DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
 );
 
 #define __show_map_type(type)						\
-	__print_symbolic(type,						\
+	__print_symbolic_u64(type,					\
 		{ EXTENT_MAP_LAST_BYTE, "LAST_BYTE" 	},		\
 		{ EXTENT_MAP_HOLE, 	"HOLE" 		},		\
 		{ EXTENT_MAP_INLINE, 	"INLINE" 	},		\
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index 3e68366..533c49f 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -205,6 +205,19 @@
 		ftrace_print_symbols_seq(p, value, symbols);		\
 	})
 
+#undef __print_symbolic_u64
+#if BITS_PER_LONG == 32
+#define __print_symbolic_u64(value, symbol_array...)			\
+	({								\
+		static const struct trace_print_flags_u64 symbols[] =	\
+			{ symbol_array, { -1, NULL } };			\
+		ftrace_print_symbols_seq_u64(p, value, symbols);	\
+	})
+#else
+#define __print_symbolic_u64(value, symbol_array...)			\
+			__print_symbolic(value, symbol_array)
+#endif
+
 #undef __print_hex
 #define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len)
 
diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
index 456be90..47aafa9 100644
--- a/kernel/trace/trace_output.c
+++ b/kernel/trace/trace_output.c
@@ -353,6 +353,33 @@ ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
 }
 EXPORT_SYMBOL(ftrace_print_symbols_seq);
 
+#if BITS_PER_LONG == 32
+const char *
+ftrace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val,
+			 const struct trace_print_flags_u64 *symbol_array)
+{
+	int i;
+	const char *ret = p->buffer + p->len;
+
+	for (i = 0;  symbol_array[i].name; i++) {
+
+		if (val != symbol_array[i].mask)
+			continue;
+
+		trace_seq_puts(p, symbol_array[i].name);
+		break;
+	}
+
+	if (!p->len)
+		trace_seq_printf(p, "0x%llx", val);
+
+	trace_seq_putc(p, 0);
+
+	return ret;
+}
+EXPORT_SYMBOL(ftrace_print_symbols_seq_u64);
+#endif
+
 const char *
 ftrace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len)
 {
-- 
1.6.5.2

Re: [PATCH] Trace: add __print_symbolic_u64 to avoid warnings on 32bit machine

[Randy Dunlap]

On Wed, 06 Apr 2011 17:18:46 +0800 liubo wrote:

> 
> Btrfs has some "ULL" macros, and when these macros are passed to tracepoints'
> __print_symbolic(), there will be 64->32 truncate WARNINGS during compiling
> on 32bit box.

Hi,

Can this also be used to stop this warning that has been around
like forever (on i386)?

linux-next-20110415/fs/xfs/linux-2.6/./xfs_trace.h:1354: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'


thanks,
---
~Randy
*** Remember to use Documentation/SubmitChecklist when testing your code ***

Re: [PATCH] Trace: add __print_symbolic_u64 to avoid warnings on 32bit machine

[Christoph Hellwig]

On Fri, Apr 15, 2011 at 09:24:18AM -0700, Randy Dunlap wrote:
> Can this also be used to stop this warning that has been around
> like forever (on i386)?
> 
> linux-next-20110415/fs/xfs/linux-2.6/./xfs_trace.h:1354: warning: format '%llx' expects type 'long long unsigned int', but argument 22 has type 'xfs_fsblock_t'

What about reporting the bug?  And no, it won't help.  The only
thing that helps would be casting the argument to (long long).  If you
send me (and/or the xfs list) a list of the warnings you see I'm happy
to fix them, although I don't see them during my x86 builds.  Could it
be that you have CONFIG_LBD disabled?  That's surely not a popular
option with XFS users.

Re: [PATCH] Trace: add __print_symbolic_u64 to avoid warnings on 32bit machine

[Steven Rostedt]

On Wed, 2011-04-06 at 17:18 +0800, liubo wrote:
> Btrfs has some "ULL" macros, and when these macros are passed to tracepoints'
> __print_symbolic(), there will be 64->32 truncate WARNINGS during compiling
> on 32bit box.
> 
> Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
> ---
>  include/linux/ftrace_event.h |   12 ++++++++++++
>  include/trace/events/btrfs.h |    4 ++--
>  include/trace/ftrace.h       |   13 +++++++++++++
>  kernel/trace/trace_output.c  |   27 +++++++++++++++++++++++++++
>  4 files changed, 54 insertions(+), 2 deletions(-)

Could you break this up into two patches. One that touches the ftrace
core, and one that updates btrfs.

Thanks,

-- Steve

Re: [PATCH] Trace: add __print_symbolic_u64 to avoid warnings on 32bit machine

[liubo]

On 04/19/2011 02:11 AM, Steven Rostedt wrote:
> On Wed, 2011-04-06 at 17:18 +0800, liubo wrote:
>> Btrfs has some "ULL" macros, and when these macros are passed to tracepoints'
>> __print_symbolic(), there will be 64->32 truncate WARNINGS during compiling
>> on 32bit box.
>>
>> Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
>> ---
>>  include/linux/ftrace_event.h |   12 ++++++++++++
>>  include/trace/events/btrfs.h |    4 ++--
>>  include/trace/ftrace.h       |   13 +++++++++++++
>>  kernel/trace/trace_output.c  |   27 +++++++++++++++++++++++++++
>>  4 files changed, 54 insertions(+), 2 deletions(-)
> 
> Could you break this up into two patches. One that touches the ftrace
> core, and one that updates btrfs.
> 

Sure, I'll break it and resend soon.  Thanks for the reply.

thanks,
liubo

> Thanks,
> 
> -- Steve
> 
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at  http://www.tux.org/lkml/
> 

[PATCH 1/2] tracing: add __print_symbolic_u64 to avoid warnings on 32bit machine

[liubo]

Filesystem, like Btrfs, has some "ULL" macros, and when these macros are passed
to tracepoints'__print_symbolic(), there will be 64->32 truncate WARNINGS during
compiling on 32bit box.

Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
---
 include/linux/ftrace_event.h |   12 ++++++++++++
 include/trace/ftrace.h       |   13 +++++++++++++
 kernel/trace/trace_output.c  |   27 +++++++++++++++++++++++++++
 3 files changed, 52 insertions(+), 0 deletions(-)

diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 47e3997..efb2330 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -16,6 +16,11 @@ struct trace_print_flags {
 	const char		*name;
 };
 
+struct trace_print_flags_u64 {
+	unsigned long long	mask;
+	const char		*name;
+};
+
 const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
 				   unsigned long flags,
 				   const struct trace_print_flags *flag_array);
@@ -23,6 +28,13 @@ const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
 const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
 				     const struct trace_print_flags *symbol_array);
 
+#if BITS_PER_LONG == 32
+const char *ftrace_print_symbols_seq_u64(struct trace_seq *p,
+					 unsigned long long val,
+					 const struct trace_print_flags_u64
+								 *symbol_array);
+#endif
+
 const char *ftrace_print_hex_seq(struct trace_seq *p,
 				 const unsigned char *buf, int len);
 
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index 3e68366..533c49f 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -205,6 +205,19 @@
 		ftrace_print_symbols_seq(p, value, symbols);		\
 	})
 
+#undef __print_symbolic_u64
+#if BITS_PER_LONG == 32
+#define __print_symbolic_u64(value, symbol_array...)			\
+	({								\
+		static const struct trace_print_flags_u64 symbols[] =	\
+			{ symbol_array, { -1, NULL } };			\
+		ftrace_print_symbols_seq_u64(p, value, symbols);	\
+	})
+#else
+#define __print_symbolic_u64(value, symbol_array...)			\
+			__print_symbolic(value, symbol_array)
+#endif
+
 #undef __print_hex
 #define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len)
 
diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
index 02272ba..b783504 100644
--- a/kernel/trace/trace_output.c
+++ b/kernel/trace/trace_output.c
@@ -353,6 +353,33 @@ ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
 }
 EXPORT_SYMBOL(ftrace_print_symbols_seq);
 
+#if BITS_PER_LONG == 32
+const char *
+ftrace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val,
+			 const struct trace_print_flags_u64 *symbol_array)
+{
+	int i;
+	const char *ret = p->buffer + p->len;
+
+	for (i = 0;  symbol_array[i].name; i++) {
+
+		if (val != symbol_array[i].mask)
+			continue;
+
+		trace_seq_puts(p, symbol_array[i].name);
+		break;
+	}
+
+	if (!p->len)
+		trace_seq_printf(p, "0x%llx", val);
+
+	trace_seq_putc(p, 0);
+
+	return ret;
+}
+EXPORT_SYMBOL(ftrace_print_symbols_seq_u64);
+#endif
+
 const char *
 ftrace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len)
 {
-- 
1.6.5.2

Re: [PATCH 1/2] tracing: add __print_symbolic_u64 to avoid warnings on 32bit machine

[liubo]

ping?

On 04/19/2011 09:35 AM, liubo wrote:
> Filesystem, like Btrfs, has some "ULL" macros, and when these macros are passed
> to tracepoints'__print_symbolic(), there will be 64->32 truncate WARNINGS during
> compiling on 32bit box.
> 
> Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
> ---
>  include/linux/ftrace_event.h |   12 ++++++++++++
>  include/trace/ftrace.h       |   13 +++++++++++++
>  kernel/trace/trace_output.c  |   27 +++++++++++++++++++++++++++
>  3 files changed, 52 insertions(+), 0 deletions(-)
> 
> diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
> index 47e3997..efb2330 100644
> --- a/include/linux/ftrace_event.h
> +++ b/include/linux/ftrace_event.h
> @@ -16,6 +16,11 @@ struct trace_print_flags {
>  	const char		*name;
>  };
>  
> +struct trace_print_flags_u64 {
> +	unsigned long long	mask;
> +	const char		*name;
> +};
> +
>  const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
>  				   unsigned long flags,
>  				   const struct trace_print_flags *flag_array);
> @@ -23,6 +28,13 @@ const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
>  const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
>  				     const struct trace_print_flags *symbol_array);
>  
> +#if BITS_PER_LONG == 32
> +const char *ftrace_print_symbols_seq_u64(struct trace_seq *p,
> +					 unsigned long long val,
> +					 const struct trace_print_flags_u64
> +								 *symbol_array);
> +#endif
> +
>  const char *ftrace_print_hex_seq(struct trace_seq *p,
>  				 const unsigned char *buf, int len);
>  
> diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
> index 3e68366..533c49f 100644
> --- a/include/trace/ftrace.h
> +++ b/include/trace/ftrace.h
> @@ -205,6 +205,19 @@
>  		ftrace_print_symbols_seq(p, value, symbols);		\
>  	})
>  
> +#undef __print_symbolic_u64
> +#if BITS_PER_LONG == 32
> +#define __print_symbolic_u64(value, symbol_array...)			\
> +	({								\
> +		static const struct trace_print_flags_u64 symbols[] =	\
> +			{ symbol_array, { -1, NULL } };			\
> +		ftrace_print_symbols_seq_u64(p, value, symbols);	\
> +	})
> +#else
> +#define __print_symbolic_u64(value, symbol_array...)			\
> +			__print_symbolic(value, symbol_array)
> +#endif
> +
>  #undef __print_hex
>  #define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len)
>  
> diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
> index 02272ba..b783504 100644
> --- a/kernel/trace/trace_output.c
> +++ b/kernel/trace/trace_output.c
> @@ -353,6 +353,33 @@ ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
>  }
>  EXPORT_SYMBOL(ftrace_print_symbols_seq);
>  
> +#if BITS_PER_LONG == 32
> +const char *
> +ftrace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val,
> +			 const struct trace_print_flags_u64 *symbol_array)
> +{
> +	int i;
> +	const char *ret = p->buffer + p->len;
> +
> +	for (i = 0;  symbol_array[i].name; i++) {
> +
> +		if (val != symbol_array[i].mask)
> +			continue;
> +
> +		trace_seq_puts(p, symbol_array[i].name);
> +		break;
> +	}
> +
> +	if (!p->len)
> +		trace_seq_printf(p, "0x%llx", val);
> +
> +	trace_seq_putc(p, 0);
> +
> +	return ret;
> +}
> +EXPORT_SYMBOL(ftrace_print_symbols_seq_u64);
> +#endif
> +
>  const char *
>  ftrace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len)
>  {

Re: [PATCH 1/2] tracing: add __print_symbolic_u64 to avoid warnings on 32bit machine

[Steven Rostedt]

On Fri, 2011-04-29 at 18:01 +0800, liubo wrote:
> ping?

Sorry, I've been trying to get the new ftrace function tracer features
out ASAP. I plan on looking at this when I'm done.

Thanks,

-- Steve

> 
> On 04/19/2011 09:35 AM, liubo wrote:
> > Filesystem, like Btrfs, has some "ULL" macros, and when these macros are passed
> > to tracepoints'__print_symbolic(), there will be 64->32 truncate WARNINGS during
> > compiling on 32bit box.
> > 
> > Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
> > ---
> >  include/linux/ftrace_event.h |   12 ++++++++++++
> >  include/trace/ftrace.h       |   13 +++++++++++++
> >  kernel/trace/trace_output.c  |   27 +++++++++++++++++++++++++++
> >  3 files changed, 52 insertions(+), 0 deletions(-)
> > 
> > diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
> > index 47e3997..efb2330 100644
> > --- a/include/linux/ftrace_event.h
> > +++ b/include/linux/ftrace_event.h
> > @@ -16,6 +16,11 @@ struct trace_print_flags {
> >  	const char		*name;
> >  };
> >  
> > +struct trace_print_flags_u64 {
> > +	unsigned long long	mask;
> > +	const char		*name;
> > +};
> > +
> >  const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
> >  				   unsigned long flags,
> >  				   const struct trace_print_flags *flag_array);
> > @@ -23,6 +28,13 @@ const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
> >  const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
> >  				     const struct trace_print_flags *symbol_array);
> >  
> > +#if BITS_PER_LONG == 32
> > +const char *ftrace_print_symbols_seq_u64(struct trace_seq *p,
> > +					 unsigned long long val,
> > +					 const struct trace_print_flags_u64
> > +								 *symbol_array);
> > +#endif
> > +
> >  const char *ftrace_print_hex_seq(struct trace_seq *p,
> >  				 const unsigned char *buf, int len);
> >  
> > diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
> > index 3e68366..533c49f 100644
> > --- a/include/trace/ftrace.h
> > +++ b/include/trace/ftrace.h
> > @@ -205,6 +205,19 @@
> >  		ftrace_print_symbols_seq(p, value, symbols);		\
> >  	})
> >  
> > +#undef __print_symbolic_u64
> > +#if BITS_PER_LONG == 32
> > +#define __print_symbolic_u64(value, symbol_array...)			\
> > +	({								\
> > +		static const struct trace_print_flags_u64 symbols[] =	\
> > +			{ symbol_array, { -1, NULL } };			\
> > +		ftrace_print_symbols_seq_u64(p, value, symbols);	\
> > +	})
> > +#else
> > +#define __print_symbolic_u64(value, symbol_array...)			\
> > +			__print_symbolic(value, symbol_array)
> > +#endif
> > +
> >  #undef __print_hex
> >  #define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len)
> >  
> > diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
> > index 02272ba..b783504 100644
> > --- a/kernel/trace/trace_output.c
> > +++ b/kernel/trace/trace_output.c
> > @@ -353,6 +353,33 @@ ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
> >  }
> >  EXPORT_SYMBOL(ftrace_print_symbols_seq);
> >  
> > +#if BITS_PER_LONG == 32
> > +const char *
> > +ftrace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val,
> > +			 const struct trace_print_flags_u64 *symbol_array)
> > +{
> > +	int i;
> > +	const char *ret = p->buffer + p->len;
> > +
> > +	for (i = 0;  symbol_array[i].name; i++) {
> > +
> > +		if (val != symbol_array[i].mask)
> > +			continue;
> > +
> > +		trace_seq_puts(p, symbol_array[i].name);
> > +		break;
> > +	}
> > +
> > +	if (!p->len)
> > +		trace_seq_printf(p, "0x%llx", val);
> > +
> > +	trace_seq_putc(p, 0);
> > +
> > +	return ret;
> > +}
> > +EXPORT_SYMBOL(ftrace_print_symbols_seq_u64);
> > +#endif
> > +
> >  const char *
> >  ftrace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len)
> >  {

Re: [PATCH 1/2] tracing: add __print_symbolic_u64 to avoid warnings on 32bit machine

[liubo]

On 05/01/2011 11:35 AM, Steven Rostedt wrote:
> On Fri, 2011-04-29 at 18:01 +0800, liubo wrote:
>> ping?
> 
> Sorry, I've been trying to get the new ftrace function tracer features
> out ASAP. I plan on looking at this when I'm done.
> 
> Thanks,
> 

Hi, Steven,

I've seen your latest git-pull, but these 2 patches are not included yet,
so is there any problem with them?

If it does, I can be helpful. :)

thanks,
liubo

> -- Steve
> 
>> On 04/19/2011 09:35 AM, liubo wrote:
>>> Filesystem, like Btrfs, has some "ULL" macros, and when these macros are passed
>>> to tracepoints'__print_symbolic(), there will be 64->32 truncate WARNINGS during
>>> compiling on 32bit box.
>>>
>>> Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
>>> ---
>>>  include/linux/ftrace_event.h |   12 ++++++++++++
>>>  include/trace/ftrace.h       |   13 +++++++++++++
>>>  kernel/trace/trace_output.c  |   27 +++++++++++++++++++++++++++
>>>  3 files changed, 52 insertions(+), 0 deletions(-)
>>>
>>> diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
>>> index 47e3997..efb2330 100644
>>> --- a/include/linux/ftrace_event.h
>>> +++ b/include/linux/ftrace_event.h
>>> @@ -16,6 +16,11 @@ struct trace_print_flags {
>>>  	const char		*name;
>>>  };
>>>  
>>> +struct trace_print_flags_u64 {
>>> +	unsigned long long	mask;
>>> +	const char		*name;
>>> +};
>>> +
>>>  const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
>>>  				   unsigned long flags,
>>>  				   const struct trace_print_flags *flag_array);
>>> @@ -23,6 +28,13 @@ const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
>>>  const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
>>>  				     const struct trace_print_flags *symbol_array);
>>>  
>>> +#if BITS_PER_LONG == 32
>>> +const char *ftrace_print_symbols_seq_u64(struct trace_seq *p,
>>> +					 unsigned long long val,
>>> +					 const struct trace_print_flags_u64
>>> +								 *symbol_array);
>>> +#endif
>>> +
>>>  const char *ftrace_print_hex_seq(struct trace_seq *p,
>>>  				 const unsigned char *buf, int len);
>>>  
>>> diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
>>> index 3e68366..533c49f 100644
>>> --- a/include/trace/ftrace.h
>>> +++ b/include/trace/ftrace.h
>>> @@ -205,6 +205,19 @@
>>>  		ftrace_print_symbols_seq(p, value, symbols);		\
>>>  	})
>>>  
>>> +#undef __print_symbolic_u64
>>> +#if BITS_PER_LONG == 32
>>> +#define __print_symbolic_u64(value, symbol_array...)			\
>>> +	({								\
>>> +		static const struct trace_print_flags_u64 symbols[] =	\
>>> +			{ symbol_array, { -1, NULL } };			\
>>> +		ftrace_print_symbols_seq_u64(p, value, symbols);	\
>>> +	})
>>> +#else
>>> +#define __print_symbolic_u64(value, symbol_array...)			\
>>> +			__print_symbolic(value, symbol_array)
>>> +#endif
>>> +
>>>  #undef __print_hex
>>>  #define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len)
>>>  
>>> diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
>>> index 02272ba..b783504 100644
>>> --- a/kernel/trace/trace_output.c
>>> +++ b/kernel/trace/trace_output.c
>>> @@ -353,6 +353,33 @@ ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
>>>  }
>>>  EXPORT_SYMBOL(ftrace_print_symbols_seq);
>>>  
>>> +#if BITS_PER_LONG == 32
>>> +const char *
>>> +ftrace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val,
>>> +			 const struct trace_print_flags_u64 *symbol_array)
>>> +{
>>> +	int i;
>>> +	const char *ret = p->buffer + p->len;
>>> +
>>> +	for (i = 0;  symbol_array[i].name; i++) {
>>> +
>>> +		if (val != symbol_array[i].mask)
>>> +			continue;
>>> +
>>> +		trace_seq_puts(p, symbol_array[i].name);
>>> +		break;
>>> +	}
>>> +
>>> +	if (!p->len)
>>> +		trace_seq_printf(p, "0x%llx", val);
>>> +
>>> +	trace_seq_putc(p, 0);
>>> +
>>> +	return ret;
>>> +}
>>> +EXPORT_SYMBOL(ftrace_print_symbols_seq_u64);
>>> +#endif
>>> +
>>>  const char *
>>>  ftrace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len)
>>>  {
> 
> 
> 

Re: [PATCH 1/2] tracing: add __print_symbolic_u64 to avoid warnings on 32bit machine

[Steven Rostedt]

On Thu, 2011-05-26 at 01:49 -0400, liubo wrote:
> On 05/01/2011 11:35 AM, Steven Rostedt wrote:
> > On Fri, 2011-04-29 at 18:01 +0800, liubo wrote:
> >> ping?
> > 
> > Sorry, I've been trying to get the new ftrace function tracer features
> > out ASAP. I plan on looking at this when I'm done.
> > 
> > Thanks,
> > 
> 
> Hi, Steven,
> 
> I've seen your latest git-pull, but these 2 patches are not included yet,
> so is there any problem with them?

Actually, I was trying to get out what I had. There's a bit more patches
that I need to process still. This being one of them.

But what I sent out previously is not going into 2.6.40 anyway. Ingo
feels that it's too late in the merge window to pull those changes and
wants to wait till the next merge window. Since there's some fixes in
that pull request, I'll need to cherry pick them out and rebase the rest
for the next window.

I'll look at this patch soon. It's still in my queue "todo" ;)

-- Steve

> 
> If it does, I can be helpful. :)

Re: [PATCH 1/2] tracing: add __print_symbolic_u64 to avoid warnings on 32bit machine

[Randy Dunlap]

On Wed, 25 May 2011 08:27:44 -0400 Steven Rostedt wrote:

> On Thu, 2011-05-26 at 01:49 -0400, liubo wrote:
> > On 05/01/2011 11:35 AM, Steven Rostedt wrote:
> > > On Fri, 2011-04-29 at 18:01 +0800, liubo wrote:
> > >> ping?
> > > 
> > > Sorry, I've been trying to get the new ftrace function tracer features
> > > out ASAP. I plan on looking at this when I'm done.
> > > 
> > > Thanks,
> > > 
> > 
> > Hi, Steven,
> > 
> > I've seen your latest git-pull, but these 2 patches are not included yet,
> > so is there any problem with them?
> 
> Actually, I was trying to get out what I had. There's a bit more patches
> that I need to process still. This being one of them.
> 
> But what I sent out previously is not going into 2.6.40 anyway. Ingo
> feels that it's too late in the merge window to pull those changes and
> wants to wait till the next merge window. Since there's some fixes in
> that pull request, I'll need to cherry pick them out and rebase the rest
> for the next window.

Sorry to hear all of that.  This fix is needed in mainline.

> I'll look at this patch soon. It's still in my queue "todo" ;)
> 
> -- Steve
> 
> > 
> > If it does, I can be helpful. :)


---
~Randy
*** Remember to use Documentation/SubmitChecklist when testing your code ***

Re: [PATCH 1/2] tracing: add __print_symbolic_u64 to avoid warnings on 32bit machine

[Steven Rostedt]

On Wed, 2011-05-25 at 09:12 -0700, Randy Dunlap wrote:
>  
> > But what I sent out previously is not going into 2.6.40 anyway. Ingo
> > feels that it's too late in the merge window to pull those changes and
> > wants to wait till the next merge window. Since there's some fixes in
> > that pull request, I'll need to cherry pick them out and rebase the rest
> > for the next window.
> 
> Sorry to hear all of that.  This fix is needed in mainline.
> 

Hmm, it is a warning fix. Well, I could add this to the cherry picking
I'm doing (fixes only).

I'm currently making a fix for a triple fault in the function tracer
caused by PROVE_RCU causing recursive tracing. When I get this fixed,
I'll be pushing the "fixes" next.

Thanks!

-- Steve

Re: [PATCH 1/2] tracing: add __print_symbolic_u64 to avoid warnings on 32bit machine

[Randy Dunlap]

On 05/25/11 09:47, Steven Rostedt wrote:
> On Wed, 2011-05-25 at 09:12 -0700, Randy Dunlap wrote:
>>  
>>> But what I sent out previously is not going into 2.6.40 anyway. Ingo
>>> feels that it's too late in the merge window to pull those changes and
>>> wants to wait till the next merge window. Since there's some fixes in
>>> that pull request, I'll need to cherry pick them out and rebase the rest
>>> for the next window.
>>
>> Sorry to hear all of that.  This fix is needed in mainline.
>>
> 
> Hmm, it is a warning fix. Well, I could add this to the cherry picking
> I'm doing (fixes only).

Yes, I know.  And it clutters up a build file with 59 warnings for btrfs.h.  :(

> I'm currently making a fix for a triple fault in the function tracer
> caused by PROVE_RCU causing recursive tracing. When I get this fixed,
> I'll be pushing the "fixes" next.


-- 
~Randy
*** Remember to use Documentation/SubmitChecklist when testing your code ***

Re: [PATCH 1/2] tracing: add __print_symbolic_u64 to avoid warnings on 32bit machine

[Li Zefan]

Steven Rostedt wrote:
> On Wed, 2011-05-25 at 09:12 -0700, Randy Dunlap wrote:
>>  
>>> But what I sent out previously is not going into 2.6.40 anyway. Ingo
>>> feels that it's too late in the merge window to pull those changes and
>>> wants to wait till the next merge window. Since there's some fixes in
>>> that pull request, I'll need to cherry pick them out and rebase the rest
>>> for the next window.
>>
>> Sorry to hear all of that.  This fix is needed in mainline.
>>
> 
> Hmm, it is a warning fix. Well, I could add this to the cherry picking
> I'm doing (fixes only).
> 
> I'm currently making a fix for a triple fault in the function tracer
> caused by PROVE_RCU causing recursive tracing. When I get this fixed,
> I'll be pushing the "fixes" next.
> 

Actually it's more than a compile warning fix.

After a variable is cast from u64 to u32 and passed to __print_symbolic(),
we'll see incorrect result in the trace output.

Re: [PATCH 1/2] tracing: add __print_symbolic_u64 to avoid warnings on 32bit machine

[Steven Rostedt]

On Thu, 2011-05-26 at 09:08 +0800, Li Zefan wrote:
> Steven Rostedt wrote:

> Actually it's more than a compile warning fix.
> 
> After a variable is cast from u64 to u32 and passed to __print_symbolic(),
> we'll see incorrect result in the trace output.

Don't worry, I didn't even say a warning fix was not reason to get into
this merge window.

There was only two patches in my last pull request that were not fixing
a bug and/or warning, but adding enhancements. I rebased without them
and even added this patch and another bug fix patch to get ready to push
out.

After my ktest runs are done (I test each patch on x86_64 and x86_32,
and then compile test them on a bunch of other archs), I'll do another
git pull request for this merge window.

Thanks!

-- Steve

[tip:perf/urgent] tracing: Add __print_symbolic_u64 to avoid warnings on 32bit machine

[tip-bot for liubo]

Commit-ID:  2fc1b6f0d0a719e1e2a30bf076a3a799feaf6af2
Gitweb:     http://git.kernel.org/tip/2fc1b6f0d0a719e1e2a30bf076a3a799feaf6af2
Author:     liubo <liubo2009@cn.fujitsu.com>
AuthorDate: Tue, 19 Apr 2011 09:35:28 +0800
Committer:  Steven Rostedt <rostedt@goodmis.org>
CommitDate: Wed, 25 May 2011 22:13:44 -0400

tracing: Add __print_symbolic_u64 to avoid warnings on 32bit machine

Filesystem, like Btrfs, has some "ULL" macros, and when these macros are passed
to tracepoints'__print_symbolic(), there will be 64->32 truncate WARNINGS during
compiling on 32bit box.

Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Link: http://lkml.kernel.org/r/4DACE6E0.7000507@cn.fujitsu.com
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
---
 include/linux/ftrace_event.h |   12 ++++++++++++
 include/trace/ftrace.h       |   13 +++++++++++++
 kernel/trace/trace_output.c  |   27 +++++++++++++++++++++++++++
 3 files changed, 52 insertions(+), 0 deletions(-)

diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index b5a550a..59d3ef1 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -16,6 +16,11 @@ struct trace_print_flags {
 	const char		*name;
 };
 
+struct trace_print_flags_u64 {
+	unsigned long long	mask;
+	const char		*name;
+};
+
 const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
 				   unsigned long flags,
 				   const struct trace_print_flags *flag_array);
@@ -23,6 +28,13 @@ const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
 const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
 				     const struct trace_print_flags *symbol_array);
 
+#if BITS_PER_LONG == 32
+const char *ftrace_print_symbols_seq_u64(struct trace_seq *p,
+					 unsigned long long val,
+					 const struct trace_print_flags_u64
+								 *symbol_array);
+#endif
+
 const char *ftrace_print_hex_seq(struct trace_seq *p,
 				 const unsigned char *buf, int len);
 
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index 3e68366..533c49f 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -205,6 +205,19 @@
 		ftrace_print_symbols_seq(p, value, symbols);		\
 	})
 
+#undef __print_symbolic_u64
+#if BITS_PER_LONG == 32
+#define __print_symbolic_u64(value, symbol_array...)			\
+	({								\
+		static const struct trace_print_flags_u64 symbols[] =	\
+			{ symbol_array, { -1, NULL } };			\
+		ftrace_print_symbols_seq_u64(p, value, symbols);	\
+	})
+#else
+#define __print_symbolic_u64(value, symbol_array...)			\
+			__print_symbolic(value, symbol_array)
+#endif
+
 #undef __print_hex
 #define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len)
 
diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
index cf535cc..e37de49 100644
--- a/kernel/trace/trace_output.c
+++ b/kernel/trace/trace_output.c
@@ -353,6 +353,33 @@ ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
 }
 EXPORT_SYMBOL(ftrace_print_symbols_seq);
 
+#if BITS_PER_LONG == 32
+const char *
+ftrace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val,
+			 const struct trace_print_flags_u64 *symbol_array)
+{
+	int i;
+	const char *ret = p->buffer + p->len;
+
+	for (i = 0;  symbol_array[i].name; i++) {
+
+		if (val != symbol_array[i].mask)
+			continue;
+
+		trace_seq_puts(p, symbol_array[i].name);
+		break;
+	}
+
+	if (!p->len)
+		trace_seq_printf(p, "0x%llx", val);
+
+	trace_seq_putc(p, 0);
+
+	return ret;
+}
+EXPORT_SYMBOL(ftrace_print_symbols_seq_u64);
+#endif
+
 const char *
 ftrace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len)
 {

[PATCH 2/2] tracing: update btrfs's tracepoints to use u64 interface

[liubo]

To avoid 64->32 truncating WARNING, update btrfs's tracepoints.

Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
---
 include/trace/events/btrfs.h |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index f445cff..4114129 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -28,7 +28,7 @@ struct extent_buffer;
 		{ BTRFS_SHARED_DATA_REF_KEY, 	"SHARED_DATA_REF" })
 
 #define __show_root_type(obj)						\
-	__print_symbolic(obj,						\
+	__print_symbolic_u64(obj,					\
 		{ BTRFS_ROOT_TREE_OBJECTID, 	"ROOT_TREE"	},	\
 		{ BTRFS_EXTENT_TREE_OBJECTID, 	"EXTENT_TREE"	},	\
 		{ BTRFS_CHUNK_TREE_OBJECTID, 	"CHUNK_TREE"	},	\
@@ -125,7 +125,7 @@ DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
 );
 
 #define __show_map_type(type)						\
-	__print_symbolic(type,						\
+	__print_symbolic_u64(type,					\
 		{ EXTENT_MAP_LAST_BYTE, "LAST_BYTE" 	},		\
 		{ EXTENT_MAP_HOLE, 	"HOLE" 		},		\
 		{ EXTENT_MAP_INLINE, 	"INLINE" 	},		\
-- 
1.6.5.2

[tip:perf/urgent] tracing: Update btrfs's tracepoints to use u64 interface

[tip-bot for liubo]

Commit-ID:  7f34b746f79c1e1f8fd6d09799d133263ae7a504
Gitweb:     http://git.kernel.org/tip/7f34b746f79c1e1f8fd6d09799d133263ae7a504
Author:     liubo <liubo2009@cn.fujitsu.com>
AuthorDate: Tue, 19 Apr 2011 09:35:31 +0800
Committer:  Steven Rostedt <rostedt@goodmis.org>
CommitDate: Wed, 25 May 2011 22:13:47 -0400

tracing: Update btrfs's tracepoints to use u64 interface

To avoid 64->32 truncating WARNING, update btrfs's tracepoints.

Signed-off-by: Liu Bo <liubo2009@cn.fujitsu.com>
Link: http://lkml.kernel.org/r/4DACE6E3.8080200@cn.fujitsu.com
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
---
 include/trace/events/btrfs.h |    4 ++--
 1 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index f445cff..4114129 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -28,7 +28,7 @@ struct extent_buffer;
 		{ BTRFS_SHARED_DATA_REF_KEY, 	"SHARED_DATA_REF" })
 
 #define __show_root_type(obj)						\
-	__print_symbolic(obj,						\
+	__print_symbolic_u64(obj,					\
 		{ BTRFS_ROOT_TREE_OBJECTID, 	"ROOT_TREE"	},	\
 		{ BTRFS_EXTENT_TREE_OBJECTID, 	"EXTENT_TREE"	},	\
 		{ BTRFS_CHUNK_TREE_OBJECTID, 	"CHUNK_TREE"	},	\
@@ -125,7 +125,7 @@ DEFINE_EVENT(btrfs__inode, btrfs_inode_evict,
 );
 
 #define __show_map_type(type)						\
-	__print_symbolic(type,						\
+	__print_symbolic_u64(type,					\
 		{ EXTENT_MAP_LAST_BYTE, "LAST_BYTE" 	},		\
 		{ EXTENT_MAP_HOLE, 	"HOLE" 		},		\
 		{ EXTENT_MAP_INLINE, 	"INLINE" 	},		\