aboutsummaryrefslogtreecommitdiffstats
path: root/include
diff options
context:
space:
mode:
authorSteven Rostedt (Red Hat) <srostedt@redhat.com>2013-03-06 21:45:37 -0500
committerSteven Rostedt <rostedt@goodmis.org>2013-03-15 00:35:51 -0400
commitad909e21bbe69f1d39055d346540abd827190eca (patch)
tree0bb6dc03e46ab15d3fef884029bf1c4c8b3c172a /include
parenta695cb5816228f86576f5f5c6809fdf8ed382ece (diff)
tracing: Add internal tracing_snapshot() functions
The new snapshot feature is quite handy. It's a way for the user to take advantage of the spare buffer that, until then, only the latency tracers used to "snapshot" the buffer when it hit a max latency. Now users can trigger a "snapshot" manually when some condition is hit in a program. But a snapshot currently can not be triggered by a condition inside the kernel. With the addition of tracing_snapshot() and tracing_snapshot_alloc(), snapshots can now be taking when a condition is hit, and the developer wants to snapshot the case without stopping the trace. Note, any snapshot will overwrite the old one, so take care in how this is done. These new functions are to be used like tracing_on(), tracing_off() and trace_printk() are. That is, they should never be called in the mainline Linux kernel. They are solely for the purpose of debugging. The tracing_snapshot() will not allocate a buffer, but it is safe to be called from any context (except NMIs). But if a snapshot buffer isn't allocated when it is called, it will write to the live buffer, complaining about the lack of a snapshot buffer, and then stop tracing (giving you the "permanent snapshot"). tracing_snapshot_alloc() will allocate the snapshot buffer if it was not already allocated and then take the snapshot. This routine *may sleep*, and must be called from context that can sleep. The allocation is done with GFP_KERNEL and not atomic. If you need a snapshot in an atomic context, say in early boot, then it is best to call the tracing_snapshot_alloc() before then, where it will allocate the buffer, and then you can use the tracing_snapshot() anywhere you want and still get snapshots. Cc: Hiraku Toyooka <hiraku.toyooka.gu@hitachi.com> Cc: Thomas Gleixner <tglx@linutronix.de> Cc: Peter Zijlstra <peterz@infradead.org> Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
Diffstat (limited to 'include')
-rw-r--r--include/linux/kernel.h4
1 files changed, 4 insertions, 0 deletions
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index c566927efcbd..bc5392a326ab 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -483,6 +483,8 @@ enum ftrace_dump_mode {
483void tracing_on(void); 483void tracing_on(void);
484void tracing_off(void); 484void tracing_off(void);
485int tracing_is_on(void); 485int tracing_is_on(void);
486void tracing_snapshot(void);
487void tracing_snapshot_alloc(void);
486 488
487extern void tracing_start(void); 489extern void tracing_start(void);
488extern void tracing_stop(void); 490extern void tracing_stop(void);
@@ -570,6 +572,8 @@ static inline void trace_dump_stack(void) { }
570static inline void tracing_on(void) { } 572static inline void tracing_on(void) { }
571static inline void tracing_off(void) { } 573static inline void tracing_off(void) { }
572static inline int tracing_is_on(void) { return 0; } 574static inline int tracing_is_on(void) { return 0; }
575static inline void tracing_snapshot(void) { }
576static inline void tracing_snapshot_alloc(void) { }
573 577
574static inline __printf(1, 2) 578static inline __printf(1, 2)
575int trace_printk(const char *fmt, ...) 579int trace_printk(const char *fmt, ...)