[PATCH 1/3] Add tracing_off_event() to stop tracing when a bug or warning occur

[PATCH 1/3] Add tracing_off_event() to stop tracing when a bug or warning occur

[Chase Douglas]

The tracing_off_event() function calls tracing_off() to stop tracing
when an event occurs. By default, only BUG-type events stop tracing,
while WARNING type events do not. This is controlled through the
tracing_off={none,warn,bug} commandline parameter.

Call this function from bug and warning event handlers to enable a user
to debug their kernel by starting a trace, hitting an event, and then
retrieving trace info knowing that the trace was stopped right after the
event was hit.

Signed-off-by: Chase Douglas <chase.douglas@canonical.com>
---
 include/linux/kernel.h     |    5 +++++
 kernel/trace/ring_buffer.c |   34 ++++++++++++++++++++++++++++++++++
 2 files changed, 39 insertions(+), 0 deletions(-)

diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 7f07074..107091f 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -478,16 +478,21 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
  *
  * Most likely, you want to use tracing_on/tracing_off.
  */
+#define TRACE_EVENT_BUG 0
+#define TRACE_EVENT_WARN 1
+
 #ifdef CONFIG_RING_BUFFER
 void tracing_on(void);
 void tracing_off(void);
 /* trace_off_permanent stops recording with no way to bring it back */
 void tracing_off_permanent(void);
+void tracing_off_event(long event);
 int tracing_is_on(void);
 #else
 static inline void tracing_on(void) { }
 static inline void tracing_off(void) { }
 static inline void tracing_off_permanent(void) { }
+static inline void tracing_off_event(long event) { }
 static inline int tracing_is_on(void) { return 0; }
 #endif
 #ifdef CONFIG_TRACING
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 0287f9f..b148862 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -193,6 +193,40 @@ void tracing_off_permanent(void)
 	set_bit(RB_BUFFERS_DISABLED_BIT, &ring_buffer_flags);
 }
 
+static long tracing_event_mask = TRACE_EVENT_BUG;
+
+/**
+ * tracing_off_event - turn off tracing depending on event type
+ *
+ * This function checks the event type to determine whether tracing should be
+ * disabled. Useful for disabling tracing on bugs or warnings.
+ */
+void tracing_off_event(long event)
+{
+	if (event <= tracing_event_mask)
+		tracing_off();
+}
+EXPORT_SYMBOL_GPL(tracing_off_event);
+
+static int __init tracing_off_event_setup(char *str)
+{
+	if (!strcmp("none", str))
+		tracing_event_mask = -1;
+	else if (!strcmp("bug", str))
+		tracing_event_mask = TRACE_EVENT_BUG;
+	else if (!strcmp("warn", str))
+		tracing_event_mask = TRACE_EVENT_WARN;
+	else
+	{
+		printk(KERN_NOTICE "Invalid value passed for tracing_off parameter\n");
+		return 1;
+	}
+
+	return 0;
+}
+
+__setup("tracing_off=", tracing_off_event_setup);
+
 /**
  * tracing_is_on - show state of ring buffers enabled
  */
-- 
1.6.3.3

[PATCH 2/3] Add tracing_off_event() calls to BUG() and WARN() paths

[Chase Douglas]

This change adds tracing_off_event() calls, which stop debug tracing,
when a BUG() or WARN() function is called. The stoppage depends on
commandline paramenter tracing_off={bug,warn,none}. The default is
"bug", so only the BUG() paths will stop tracing.

Signed-off-by: Chase Douglas <chase.douglas@canonical.com>
---
 kernel/panic.c |    4 +++-
 lib/bug.c      |    2 ++
 2 files changed, 5 insertions(+), 1 deletions(-)

diff --git a/kernel/panic.c b/kernel/panic.c
index 13d966b..f0ff321 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -319,7 +319,7 @@ int oops_may_print(void)
  */
 void oops_enter(void)
 {
-	tracing_off();
+	tracing_off_event(TRACE_EVENT_BUG);
 	/* can't trust the integrity of the kernel anymore: */
 	debug_locks_off();
 	do_oops_enter_exit();
@@ -369,6 +369,8 @@ static void warn_slowpath_common(const char *file, int line, void *caller, struc
 {
 	const char *board;
 
+	tracing_off_event(TRACE_EVENT_WARN);
+
 	printk(KERN_WARNING "------------[ cut here ]------------\n");
 	printk(KERN_WARNING "WARNING: at %s:%d %pS()\n", file, line, caller);
 	board = dmi_get_system_info(DMI_PRODUCT_NAME);
diff --git a/lib/bug.c b/lib/bug.c
index 300e41a..457c1eb 100644
--- a/lib/bug.c
+++ b/lib/bug.c
@@ -154,6 +154,8 @@ enum bug_trap_type report_bug(unsigned long bugaddr, struct pt_regs *regs)
 		warning = (bug->flags & BUGFLAG_WARNING) != 0;
 	}
 
+	tracing_off_event(warning ? TRACE_EVENT_WARN : TRACE_EVENT_BUG);
+
 	if (warning) {
 		/* this is a WARN_ON rather than BUG/BUG_ON */
 		if (file)
-- 
1.6.3.3

[PATCH 3/3] Stop tracing on a schedule bug

[Chase Douglas]

This change adds a tracing_off_event() call to stop tracing on schedule
bugs unless tracing_off=none was specified on the commandline.

Signed-off-by: Chase Douglas <chase.douglas@canonical.com>
---
 kernel/sched.c |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

diff --git a/kernel/sched.c b/kernel/sched.c
index 150b698..bfe4f05 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -3589,6 +3589,8 @@ static noinline void __schedule_bug(struct task_struct *prev)
 {
 	struct pt_regs *regs = get_irq_regs();
 
+	tracing_off_event(TRACE_EVENT_BUG);
+
 	printk(KERN_ERR "BUG: scheduling while atomic: %s/%d/0x%08x\n",
 		prev->comm, prev->pid, preempt_count());
 
-- 
1.6.3.3

Re: [PATCH 1/3] Add tracing_off_event() to stop tracing when a bug or warning occur

[Steven Rostedt]

[ Expanded the Cc list ]

On Thu, 2010-03-18 at 09:48 -0400, Chase Douglas wrote:
> The tracing_off_event() function calls tracing_off() to stop tracing
> when an event occurs. By default, only BUG-type events stop tracing,
> while WARNING type events do not. This is controlled through the
> tracing_off={none,warn,bug} commandline parameter.
> 
> Call this function from bug and warning event handlers to enable a user
> to debug their kernel by starting a trace, hitting an event, and then
> retrieving trace info knowing that the trace was stopped right after the
> event was hit.
> 
> Signed-off-by: Chase Douglas <chase.douglas@canonical.com>
> ---
>  include/linux/kernel.h     |    5 +++++
>  kernel/trace/ring_buffer.c |   34 ++++++++++++++++++++++++++++++++++
>  2 files changed, 39 insertions(+), 0 deletions(-)
> 
> diff --git a/include/linux/kernel.h b/include/linux/kernel.h
> index 7f07074..107091f 100644
> --- a/include/linux/kernel.h
> +++ b/include/linux/kernel.h
> @@ -478,16 +478,21 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
>   *
>   * Most likely, you want to use tracing_on/tracing_off.
>   */
> +#define TRACE_EVENT_BUG 0
> +#define TRACE_EVENT_WARN 1

This should probably be an enum.

> +
>  #ifdef CONFIG_RING_BUFFER
>  void tracing_on(void);
>  void tracing_off(void);
>  /* trace_off_permanent stops recording with no way to bring it back */
>  void tracing_off_permanent(void);
> +void tracing_off_event(long event);
>  int tracing_is_on(void);
>  #else
>  static inline void tracing_on(void) { }
>  static inline void tracing_off(void) { }
>  static inline void tracing_off_permanent(void) { }
> +static inline void tracing_off_event(long event) { }
>  static inline int tracing_is_on(void) { return 0; }
>  #endif
>  #ifdef CONFIG_TRACING
> diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
> index 0287f9f..b148862 100644
> --- a/kernel/trace/ring_buffer.c
> +++ b/kernel/trace/ring_buffer.c
> @@ -193,6 +193,40 @@ void tracing_off_permanent(void)
>  	set_bit(RB_BUFFERS_DISABLED_BIT, &ring_buffer_flags);
>  }
>  
> +static long tracing_event_mask = TRACE_EVENT_BUG;

That's a bad name. It does not seem to be a mask but seems to be a
control setting. Maybe call it tracing_event_off_ctrl ?

-- Steve


> +
> +/**
> + * tracing_off_event - turn off tracing depending on event type
> + *
> + * This function checks the event type to determine whether tracing should be
> + * disabled. Useful for disabling tracing on bugs or warnings.
> + */
> +void tracing_off_event(long event)
> +{
> +	if (event <= tracing_event_mask)
> +		tracing_off();
> +}
> +EXPORT_SYMBOL_GPL(tracing_off_event);
> +
> +static int __init tracing_off_event_setup(char *str)
> +{
> +	if (!strcmp("none", str))
> +		tracing_event_mask = -1;
> +	else if (!strcmp("bug", str))
> +		tracing_event_mask = TRACE_EVENT_BUG;
> +	else if (!strcmp("warn", str))
> +		tracing_event_mask = TRACE_EVENT_WARN;
> +	else
> +	{
> +		printk(KERN_NOTICE "Invalid value passed for tracing_off parameter\n");
> +		return 1;
> +	}
> +
> +	return 0;
> +}
> +
> +__setup("tracing_off=", tracing_off_event_setup);
> +
>  /**
>   * tracing_is_on - show state of ring buffers enabled
>   */

Re: [PATCH 1/3] Add tracing_off_event() to stop tracing when a bug or warning occur

[Chase Douglas]

On Thu, Mar 18, 2010 at 10:56 AM, Steven Rostedt <rostedt@goodmis.org> wrote:
> [ Expanded the Cc list ]
>
> On Thu, 2010-03-18 at 09:48 -0400, Chase Douglas wrote:
>> The tracing_off_event() function calls tracing_off() to stop tracing
>> when an event occurs. By default, only BUG-type events stop tracing,
>> while WARNING type events do not. This is controlled through the
>> tracing_off={none,warn,bug} commandline parameter.
>>
>> Call this function from bug and warning event handlers to enable a user
>> to debug their kernel by starting a trace, hitting an event, and then
>> retrieving trace info knowing that the trace was stopped right after the
>> event was hit.
>>
>> Signed-off-by: Chase Douglas <chase.douglas@canonical.com>
>> ---
>>  include/linux/kernel.h     |    5 +++++
>>  kernel/trace/ring_buffer.c |   34 ++++++++++++++++++++++++++++++++++
>>  2 files changed, 39 insertions(+), 0 deletions(-)
>>
>> diff --git a/include/linux/kernel.h b/include/linux/kernel.h
>> index 7f07074..107091f 100644
>> --- a/include/linux/kernel.h
>> +++ b/include/linux/kernel.h
>> @@ -478,16 +478,21 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
>>   *
>>   * Most likely, you want to use tracing_on/tracing_off.
>>   */
>> +#define TRACE_EVENT_BUG 0
>> +#define TRACE_EVENT_WARN 1
>
> This should probably be an enum.
>
>> +
>>  #ifdef CONFIG_RING_BUFFER
>>  void tracing_on(void);
>>  void tracing_off(void);
>>  /* trace_off_permanent stops recording with no way to bring it back */
>>  void tracing_off_permanent(void);
>> +void tracing_off_event(long event);
>>  int tracing_is_on(void);
>>  #else
>>  static inline void tracing_on(void) { }
>>  static inline void tracing_off(void) { }
>>  static inline void tracing_off_permanent(void) { }
>> +static inline void tracing_off_event(long event) { }
>>  static inline int tracing_is_on(void) { return 0; }
>>  #endif
>>  #ifdef CONFIG_TRACING
>> diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
>> index 0287f9f..b148862 100644
>> --- a/kernel/trace/ring_buffer.c
>> +++ b/kernel/trace/ring_buffer.c
>> @@ -193,6 +193,40 @@ void tracing_off_permanent(void)
>>       set_bit(RB_BUFFERS_DISABLED_BIT, &ring_buffer_flags);
>>  }
>>
>> +static long tracing_event_mask = TRACE_EVENT_BUG;
>
> That's a bad name. It does not seem to be a mask but seems to be a
> control setting. Maybe call it tracing_event_off_ctrl ?

I'll fix these two things up and resend.

Thanks,
Chase

Re: [PATCH 1/3] Add tracing_off_event() to stop tracing when a bug or warning occur

[Randy Dunlap]

On Thu, 18 Mar 2010 09:48:50 -0400 Chase Douglas wrote:

> The tracing_off_event() function calls tracing_off() to stop tracing
> when an event occurs. By default, only BUG-type events stop tracing,
> while WARNING type events do not. This is controlled through the
> tracing_off={none,warn,bug} commandline parameter.
> 
> Call this function from bug and warning event handlers to enable a user
> to debug their kernel by starting a trace, hitting an event, and then
> retrieving trace info knowing that the trace was stopped right after the
> event was hit.
> 
> Signed-off-by: Chase Douglas <chase.douglas@canonical.com>
> ---
>  include/linux/kernel.h     |    5 +++++
>  kernel/trace/ring_buffer.c |   34 ++++++++++++++++++++++++++++++++++
>  2 files changed, 39 insertions(+), 0 deletions(-)
> 
> diff --git a/include/linux/kernel.h b/include/linux/kernel.h
> index 7f07074..107091f 100644
> --- a/include/linux/kernel.h
> +++ b/include/linux/kernel.h
> @@ -478,16 +478,21 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
>   *
>   * Most likely, you want to use tracing_on/tracing_off.
>   */
> +#define TRACE_EVENT_BUG 0
> +#define TRACE_EVENT_WARN 1
> +
>  #ifdef CONFIG_RING_BUFFER
>  void tracing_on(void);
>  void tracing_off(void);
>  /* trace_off_permanent stops recording with no way to bring it back */
>  void tracing_off_permanent(void);
> +void tracing_off_event(long event);
>  int tracing_is_on(void);
>  #else
>  static inline void tracing_on(void) { }
>  static inline void tracing_off(void) { }
>  static inline void tracing_off_permanent(void) { }
> +static inline void tracing_off_event(long event) { }
>  static inline int tracing_is_on(void) { return 0; }
>  #endif
>  #ifdef CONFIG_TRACING
> diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
> index 0287f9f..b148862 100644
> --- a/kernel/trace/ring_buffer.c
> +++ b/kernel/trace/ring_buffer.c
> @@ -193,6 +193,40 @@ void tracing_off_permanent(void)
>  	set_bit(RB_BUFFERS_DISABLED_BIT, &ring_buffer_flags);
>  }
>  
> +static long tracing_event_mask = TRACE_EVENT_BUG;
> +
> +/**
> + * tracing_off_event - turn off tracing depending on event type

Please add the function parameter to the kernel-doc to make it complete
& prevent warnings;  something like:

 * @event: which event happened


> + *
> + * This function checks the event type to determine whether tracing should be
> + * disabled. Useful for disabling tracing on bugs or warnings.
> + */
> +void tracing_off_event(long event)
> +{
> +	if (event <= tracing_event_mask)
> +		tracing_off();
> +}
> +EXPORT_SYMBOL_GPL(tracing_off_event);
> +
> +static int __init tracing_off_event_setup(char *str)
> +{
> +	if (!strcmp("none", str))
> +		tracing_event_mask = -1;
> +	else if (!strcmp("bug", str))
> +		tracing_event_mask = TRACE_EVENT_BUG;
> +	else if (!strcmp("warn", str))
> +		tracing_event_mask = TRACE_EVENT_WARN;
> +	else
> +	{
> +		printk(KERN_NOTICE "Invalid value passed for tracing_off parameter\n");
> +		return 1;
> +	}
> +
> +	return 0;
> +}
> +
> +__setup("tracing_off=", tracing_off_event_setup);
> +
>  /**
>   * tracing_is_on - show state of ring buffers enabled
>   */
> -- 


---
~Randy