Merge branch 'tracing-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip

* 'tracing-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip: (241 commits)
  sched, trace: update trace_sched_wakeup()
  tracing/ftrace: don't trace on early stage of a secondary cpu boot, v3
  Revert "x86: disable X86_PTRACE_BTS"
  ring-buffer: prevent false positive warning
  ring-buffer: fix dangling commit race
  ftrace: enable format arguments checking
  x86, bts: memory accounting
  x86, bts: add fork and exit handling
  ftrace: introduce tracing_reset_online_cpus() helper
  tracing: fix warnings in kernel/trace/trace_sched_switch.c
  tracing: fix warning in kernel/trace/trace.c
  tracing/ring-buffer: remove unused ring_buffer size
  trace: fix task state printout
  ftrace: add not to regex on filtering functions
  trace: better use of stack_trace_enabled for boot up code
  trace: add a way to enable or disable the stack tracer
  x86: entry_64 - introduce FTRACE_ frame macro v2
  tracing/ftrace: add the printk-msg-only option
  tracing/ftrace: use preempt_enable_no_resched_notrace in ring_buffer_time_stamp()
  x86, bts: correctly report invalid bts records
  ...

Fixed up trivial conflict in scripts/recordmcount.pl due to SH bits
being already partly merged by the SH merge.

16 files changed, 560 insertions, 237 deletions

diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index bdf505d33e77..1dba3493d520 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -160,7 +160,6 @@ struct blk_trace {
 
 extern int blk_trace_ioctl(struct block_device *, unsigned, char __user *);
 extern void blk_trace_shutdown(struct request_queue *);
-extern void __blk_add_trace(struct blk_trace *, sector_t, int, int, u32, int, int, void *);
 extern int do_blk_trace_setup(struct request_queue *q,
         char *name, dev_t dev, struct blk_user_trace_setup *buts);
 extern void __trace_note_message(struct blk_trace *, const char *fmt, ...);
@@ -186,168 +185,8 @@ extern void __trace_note_message(struct blk_trace *, const char *fmt, ...);
         } while (0)
 #define BLK_TN_MAX_MSG          128
 
-/**
- * blk_add_trace_rq - Add a trace for a request oriented action
- * @q:          queue the io is for
- * @rq:         the source request
- * @what:       the action
- *
- * Description:
- *     Records an action against a request. Will log the bio offset + size.
- *
- **/
-static inline void blk_add_trace_rq(struct request_queue *q, struct request *rq,
-                                    u32 what)
-{
-        struct blk_trace *bt = q->blk_trace;
-        int rw = rq->cmd_flags & 0x03;
-
-        if (likely(!bt))
-                return;
-
-        if (blk_discard_rq(rq))
-                rw |= (1 << BIO_RW_DISCARD);
-
-        if (blk_pc_request(rq)) {
-                what |= BLK_TC_ACT(BLK_TC_PC);
-                __blk_add_trace(bt, 0, rq->data_len, rw, what, rq->errors, sizeof(rq->cmd), rq->cmd);
-        } else  {
-                what |= BLK_TC_ACT(BLK_TC_FS);
-                __blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9, rw, what, rq->errors, 0, NULL);
-        }
-}
-
-/**
- * blk_add_trace_bio - Add a trace for a bio oriented action
- * @q:          queue the io is for
- * @bio:        the source bio
- * @what:       the action
- *
- * Description:
- *     Records an action against a bio. Will log the bio offset + size.
- *
- **/
-static inline void blk_add_trace_bio(struct request_queue *q, struct bio *bio,
-                                     u32 what)
-{
-        struct blk_trace *bt = q->blk_trace;
-
-        if (likely(!bt))
-                return;
-
-        __blk_add_trace(bt, bio->bi_sector, bio->bi_size, bio->bi_rw, what, !bio_flagged(bio, BIO_UPTODATE), 0, NULL);
-}
-
-/**
- * blk_add_trace_generic - Add a trace for a generic action
- * @q:          queue the io is for
- * @bio:        the source bio
- * @rw:         the data direction
- * @what:       the action
- *
- * Description:
- *     Records a simple trace
- *
- **/
-static inline void blk_add_trace_generic(struct request_queue *q,
-                                         struct bio *bio, int rw, u32 what)
-{
-        struct blk_trace *bt = q->blk_trace;
-
-        if (likely(!bt))
-                return;
-
-        if (bio)
-                blk_add_trace_bio(q, bio, what);
-        else
-                __blk_add_trace(bt, 0, 0, rw, what, 0, 0, NULL);
-}
-
-/**
- * blk_add_trace_pdu_int - Add a trace for a bio with an integer payload
- * @q:          queue the io is for
- * @what:       the action
- * @bio:        the source bio
- * @pdu:        the integer payload
- *
- * Description:
- *     Adds a trace with some integer payload. This might be an unplug
- *     option given as the action, with the depth at unplug time given
- *     as the payload
- *
- **/
-static inline void blk_add_trace_pdu_int(struct request_queue *q, u32 what,
-                                         struct bio *bio, unsigned int pdu)
-{
-        struct blk_trace *bt = q->blk_trace;
-        __be64 rpdu = cpu_to_be64(pdu);
-
-        if (likely(!bt))
-                return;
-
-        if (bio)
-                __blk_add_trace(bt, bio->bi_sector, bio->bi_size, bio->bi_rw, what, !bio_flagged(bio, BIO_UPTODATE), sizeof(rpdu), &rpdu);
-        else
-                __blk_add_trace(bt, 0, 0, 0, what, 0, sizeof(rpdu), &rpdu);
-}
-
-/**
- * blk_add_trace_remap - Add a trace for a remap operation
- * @q:          queue the io is for
- * @bio:        the source bio
- * @dev:        target device
- * @from:       source sector
- * @to:         target sector
- *
- * Description:
- *     Device mapper or raid target sometimes need to split a bio because
- *     it spans a stripe (or similar). Add a trace for that action.
- *
- **/
-static inline void blk_add_trace_remap(struct request_queue *q, struct bio *bio,
-                                       dev_t dev, sector_t from, sector_t to)
-{
-        struct blk_trace *bt = q->blk_trace;
-        struct blk_io_trace_remap r;
-
-        if (likely(!bt))
-                return;
-
-        r.device = cpu_to_be32(dev);
-        r.device_from = cpu_to_be32(bio->bi_bdev->bd_dev);
-        r.sector = cpu_to_be64(to);
-
-        __blk_add_trace(bt, from, bio->bi_size, bio->bi_rw, BLK_TA_REMAP, !bio_flagged(bio, BIO_UPTODATE), sizeof(r), &r);
-}
-
-/**
- * blk_add_driver_data - Add binary message with driver-specific data
- * @q:          queue the io is for
- * @rq:         io request
- * @data:       driver-specific data
- * @len:        length of driver-specific data
- *
- * Description:
- *     Some drivers might want to write driver-specific data per request.
- *
- **/
-static inline void blk_add_driver_data(struct request_queue *q,
-                                       struct request *rq,
-                                       void *data, size_t len)
-{
-        struct blk_trace *bt = q->blk_trace;
-
-        if (likely(!bt))
-                return;
-
-        if (blk_pc_request(rq))
-                __blk_add_trace(bt, 0, rq->data_len, 0, BLK_TA_DRV_DATA,
-                                rq->errors, len, data);
-        else
-                __blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9,
-                                0, BLK_TA_DRV_DATA, rq->errors, len, data);
-}
-
+extern void blk_add_driver_data(struct request_queue *q, struct request *rq,
+                                void *data, size_t len);
 extern int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
                            char __user *arg);
 extern int blk_trace_startstop(struct request_queue *q, int start);
@@ -356,13 +195,8 @@ extern int blk_trace_remove(struct request_queue *q);
 #else /* !CONFIG_BLK_DEV_IO_TRACE */
 #define blk_trace_ioctl(bdev, cmd, arg)         (-ENOTTY)
 #define blk_trace_shutdown(q)                   do { } while (0)
-#define blk_add_trace_rq(q, rq, what)           do { } while (0)
-#define blk_add_trace_bio(q, rq, what)          do { } while (0)
-#define blk_add_trace_generic(q, rq, rw, what)  do { } while (0)
-#define blk_add_trace_pdu_int(q, what, bio, pdu)        do { } while (0)
-#define blk_add_trace_remap(q, bio, dev, f, t)  do {} while (0)
-#define blk_add_driver_data(q, rq, data, len)   do {} while (0)
 #define do_blk_trace_setup(q, name, dev, buts)  (-ENOTTY)
+#define blk_add_driver_data(q, rq, data, len)   do {} while (0)
 #define blk_trace_setup(q, name, dev, arg)      (-ENOTTY)
 #define blk_trace_startstop(q, start)           (-ENOTTY)
 #define blk_trace_remove(q)                     (-ENOTTY)
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 98115d9d04da..ea7c6be354b7 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -59,8 +59,88 @@ extern void __chk_io_ptr(const volatile void __iomem *);
  * specific implementations come from the above header files
  */
 
-#define likely(x)       __builtin_expect(!!(x), 1)
-#define unlikely(x)     __builtin_expect(!!(x), 0)
+struct ftrace_branch_data {
+        const char *func;
+        const char *file;
+        unsigned line;
+        union {
+                struct {
+                        unsigned long correct;
+                        unsigned long incorrect;
+                };
+                struct {
+                        unsigned long miss;
+                        unsigned long hit;
+                };
+        };
+};
+
+/*
+ * Note: DISABLE_BRANCH_PROFILING can be used by special lowlevel code
+ * to disable branch tracing on a per file basis.
+ */
+#if defined(CONFIG_TRACE_BRANCH_PROFILING) && !defined(DISABLE_BRANCH_PROFILING)
+void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
+
+#define likely_notrace(x)       __builtin_expect(!!(x), 1)
+#define unlikely_notrace(x)     __builtin_expect(!!(x), 0)
+
+#define __branch_check__(x, expect) ({                                  \
+                        int ______r;                                    \
+                        static struct ftrace_branch_data                \
+                                __attribute__((__aligned__(4)))         \
+                                __attribute__((section("_ftrace_annotated_branch"))) \
+                                ______f = {                             \
+                                .func = __func__,                       \
+                                .file = __FILE__,                       \
+                                .line = __LINE__,                       \
+                        };                                              \
+                        ______r = likely_notrace(x);                    \
+                        ftrace_likely_update(&______f, ______r, expect); \
+                        ______r;                                        \
+                })
+
+/*
+ * Using __builtin_constant_p(x) to ignore cases where the return
+ * value is always the same.  This idea is taken from a similar patch
+ * written by Daniel Walker.
+ */
+# ifndef likely
+#  define likely(x)     (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 1))
+# endif
+# ifndef unlikely
+#  define unlikely(x)   (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 0))
+# endif
+
+#ifdef CONFIG_PROFILE_ALL_BRANCHES
+/*
+ * "Define 'is'", Bill Clinton
+ * "Define 'if'", Steven Rostedt
+ */
+#define if(cond) if (__builtin_constant_p((cond)) ? !!(cond) :          \
+        ({                                                              \
+                int ______r;                                            \
+                static struct ftrace_branch_data                        \
+                        __attribute__((__aligned__(4)))                 \
+                        __attribute__((section("_ftrace_branch")))      \
+                        ______f = {                                     \
+                                .func = __func__,                       \
+                                .file = __FILE__,                       \
+                                .line = __LINE__,                       \
+                        };                                              \
+                ______r = !!(cond);                                     \
+                if (______r)                                            \
+                        ______f.hit++;                                  \
+                else                                                    \
+                        ______f.miss++;                                 \
+                ______r;                                                \
+        }))
+#endif /* CONFIG_PROFILE_ALL_BRANCHES */
+
+#else
+# define likely(x)      __builtin_expect(!!(x), 1)
+# define unlikely(x)    __builtin_expect(!!(x), 0)
+#endif
 
 /* Optimization barrier */
 #ifndef barrier
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 9c5bc6be2b09..677432b9cb7e 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -8,6 +8,8 @@
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/kallsyms.h>
+#include <linux/bitops.h>
+#include <linux/sched.h>
 
 #ifdef CONFIG_FUNCTION_TRACER
 
@@ -24,6 +26,45 @@ struct ftrace_ops {
         struct ftrace_ops *next;
 };
 
+extern int function_trace_stop;
+
+/*
+ * Type of the current tracing.
+ */
+enum ftrace_tracing_type_t {
+        FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */
+        FTRACE_TYPE_RETURN,     /* Hook the return of the function */
+};
+
+/* Current tracing type, default is FTRACE_TYPE_ENTER */
+extern enum ftrace_tracing_type_t ftrace_tracing_type;
+
+/**
+ * ftrace_stop - stop function tracer.
+ *
+ * A quick way to stop the function tracer. Note this an on off switch,
+ * it is not something that is recursive like preempt_disable.
+ * This does not disable the calling of mcount, it only stops the
+ * calling of functions from mcount.
+ */
+static inline void ftrace_stop(void)
+{
+        function_trace_stop = 1;
+}
+
+/**
+ * ftrace_start - start the function tracer.
+ *
+ * This function is the inverse of ftrace_stop. This does not enable
+ * the function tracing if the function tracer is disabled. This only
+ * sets the function tracer flag to continue calling the functions
+ * from mcount.
+ */
+static inline void ftrace_start(void)
+{
+        function_trace_stop = 0;
+}
+
 /*
  * The ftrace_ops must be a static and should also
  * be read_mostly.  These functions do modify read_mostly variables
@@ -42,9 +83,21 @@ extern void ftrace_stub(unsigned long a0, unsigned long a1);
 # define unregister_ftrace_function(ops) do { } while (0)
 # define clear_ftrace_function(ops) do { } while (0)
 static inline void ftrace_kill(void) { }
+static inline void ftrace_stop(void) { }
+static inline void ftrace_start(void) { }
 #endif /* CONFIG_FUNCTION_TRACER */
 
+#ifdef CONFIG_STACK_TRACER
+extern int stack_tracer_enabled;
+int
+stack_trace_sysctl(struct ctl_table *table, int write,
+                   struct file *file, void __user *buffer, size_t *lenp,
+                   loff_t *ppos);
+#endif
+
 #ifdef CONFIG_DYNAMIC_FTRACE
+/* asm/ftrace.h must be defined for archs supporting dynamic ftrace */
+#include <asm/ftrace.h>
 
 enum {
         FTRACE_FL_FREE          = (1 << 0),
@@ -60,6 +113,7 @@ struct dyn_ftrace {
         struct list_head        list;
         unsigned long           ip; /* address of mcount call-site */
         unsigned long           flags;
+        struct dyn_arch_ftrace  arch;
 };
 
 int ftrace_force_update(void);
@@ -67,19 +121,48 @@ void ftrace_set_filter(unsigned char *buf, int len, int reset);
 
 /* defined in arch */
 extern int ftrace_ip_converted(unsigned long ip);
-extern unsigned char *ftrace_nop_replace(void);
-extern unsigned char *ftrace_call_replace(unsigned long ip, unsigned long addr);
 extern int ftrace_dyn_arch_init(void *data);
 extern int ftrace_update_ftrace_func(ftrace_func_t func);
 extern void ftrace_caller(void);
 extern void ftrace_call(void);
 extern void mcount_call(void);
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+extern void ftrace_graph_caller(void);
+extern int ftrace_enable_ftrace_graph_caller(void);
+extern int ftrace_disable_ftrace_graph_caller(void);
+#else
+static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; }
+static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; }
+#endif
+
+/**
+ * ftrace_make_nop - convert code into top
+ * @mod: module structure if called by module load initialization
+ * @rec: the mcount call site record
+ * @addr: the address that the call site should be calling
+ *
+ * This is a very sensitive operation and great care needs
+ * to be taken by the arch.  The operation should carefully
+ * read the location, check to see if what is read is indeed
+ * what we expect it to be, and then on success of the compare,
+ * it should write to the location.
+ *
+ * The code segment at @rec->ip should be a caller to @addr
+ *
+ * Return must be:
+ *  0 on success
+ *  -EFAULT on error reading the location
+ *  -EINVAL on a failed compare of the contents
+ *  -EPERM  on error writing to the location
+ * Any other value will be considered a failure.
+ */
+extern int ftrace_make_nop(struct module *mod,
+                           struct dyn_ftrace *rec, unsigned long addr);
 
 /**
- * ftrace_modify_code - modify code segment
- * @ip: the address of the code segment
- * @old_code: the contents of what is expected to be there
- * @new_code: the code to patch in
+ * ftrace_make_call - convert a nop call site into a call to addr
+ * @rec: the mcount call site record
+ * @addr: the address that the call site should call
  *
  * This is a very sensitive operation and great care needs
  * to be taken by the arch.  The operation should carefully
@@ -87,6 +170,8 @@ extern void mcount_call(void);
  * what we expect it to be, and then on success of the compare,
  * it should write to the location.
  *
+ * The code segment at @rec->ip should be a nop
+ *
  * Return must be:
  *  0 on success
  *  -EFAULT on error reading the location
@@ -94,8 +179,11 @@ extern void mcount_call(void);
  *  -EPERM  on error writing to the location
  * Any other value will be considered a failure.
  */
-extern int ftrace_modify_code(unsigned long ip, unsigned char *old_code,
-                              unsigned char *new_code);
+extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
+
+
+/* May be defined in arch */
+extern int ftrace_arch_read_dyn_info(char *buf, int size);
 
 extern int skip_trace(unsigned long ip);
 
@@ -103,7 +191,6 @@ extern void ftrace_release(void *start, unsigned long size);
 
 extern void ftrace_disable_daemon(void);
 extern void ftrace_enable_daemon(void);
-
 #else
 # define skip_trace(ip)                         ({ 0; })
 # define ftrace_force_update()                  ({ 0; })
@@ -182,6 +269,12 @@ static inline void __ftrace_enabled_restore(int enabled)
 #endif
 
 #ifdef CONFIG_TRACING
+extern int ftrace_dump_on_oops;
+
+extern void tracing_start(void);
+extern void tracing_stop(void);
+extern void ftrace_off_permanent(void);
+
 extern void
 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3);
 
@@ -210,8 +303,11 @@ extern void ftrace_dump(void);
 static inline void
 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { }
 static inline int
-ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 0)));
+ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
 
+static inline void tracing_start(void) { }
+static inline void tracing_stop(void) { }
+static inline void ftrace_off_permanent(void) { }
 static inline int
 ftrace_printk(const char *fmt, ...)
 {
@@ -222,33 +318,178 @@ static inline void ftrace_dump(void) { }
 
 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
 extern void ftrace_init(void);
-extern void ftrace_init_module(unsigned long *start, unsigned long *end);
+extern void ftrace_init_module(struct module *mod,
+                               unsigned long *start, unsigned long *end);
 #else
 static inline void ftrace_init(void) { }
 static inline void
-ftrace_init_module(unsigned long *start, unsigned long *end) { }
+ftrace_init_module(struct module *mod,
+                   unsigned long *start, unsigned long *end) { }
+#endif
+
+enum {
+        POWER_NONE = 0,
+        POWER_CSTATE = 1,
+        POWER_PSTATE = 2,
+};
+
+struct power_trace {
+#ifdef CONFIG_POWER_TRACER
+        ktime_t                 stamp;
+        ktime_t                 end;
+        int                     type;
+        int                     state;
 #endif
+};
 
+#ifdef CONFIG_POWER_TRACER
+extern void trace_power_start(struct power_trace *it, unsigned int type,
+                                        unsigned int state);
+extern void trace_power_mark(struct power_trace *it, unsigned int type,
+                                        unsigned int state);
+extern void trace_power_end(struct power_trace *it);
+#else
+static inline void trace_power_start(struct power_trace *it, unsigned int type,
+                                        unsigned int state) { }
+static inline void trace_power_mark(struct power_trace *it, unsigned int type,
+                                        unsigned int state) { }
+static inline void trace_power_end(struct power_trace *it) { }
+#endif
+
+
+/*
+ * Structure that defines an entry function trace.
+ */
+struct ftrace_graph_ent {
+        unsigned long func; /* Current function */
+        int depth;
+};
 
-struct boot_trace {
-        pid_t                   caller;
-        char                    func[KSYM_SYMBOL_LEN];
-        int                     result;
-        unsigned long long      duration;               /* usecs */
-        ktime_t                 calltime;
-        ktime_t                 rettime;
+/*
+ * Structure that defines a return function trace.
+ */
+struct ftrace_graph_ret {
+        unsigned long func; /* Current function */
+        unsigned long long calltime;
+        unsigned long long rettime;
+        /* Number of functions that overran the depth limit for current task */
+        unsigned long overrun;
+        int depth;
 };
 
-#ifdef CONFIG_BOOT_TRACER
-extern void trace_boot(struct boot_trace *it, initcall_t fn);
-extern void start_boot_trace(void);
-extern void stop_boot_trace(void);
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+
+/*
+ * Sometimes we don't want to trace a function with the function
+ * graph tracer but we want them to keep traced by the usual function
+ * tracer if the function graph tracer is not configured.
+ */
+#define __notrace_funcgraph             notrace
+
+/*
+ * We want to which function is an entrypoint of a hardirq.
+ * That will help us to put a signal on output.
+ */
+#define __irq_entry              __attribute__((__section__(".irqentry.text")))
+
+/* Limits of hardirq entrypoints */
+extern char __irqentry_text_start[];
+extern char __irqentry_text_end[];
+
+#define FTRACE_RETFUNC_DEPTH 50
+#define FTRACE_RETSTACK_ALLOC_SIZE 32
+/* Type of the callback handlers for tracing function graph*/
+typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */
+typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */
+
+extern int register_ftrace_graph(trace_func_graph_ret_t retfunc,
+                                trace_func_graph_ent_t entryfunc);
+
+extern void ftrace_graph_stop(void);
+
+/* The current handlers in use */
+extern trace_func_graph_ret_t ftrace_graph_return;
+extern trace_func_graph_ent_t ftrace_graph_entry;
+
+extern void unregister_ftrace_graph(void);
+
+extern void ftrace_graph_init_task(struct task_struct *t);
+extern void ftrace_graph_exit_task(struct task_struct *t);
+
+static inline int task_curr_ret_stack(struct task_struct *t)
+{
+        return t->curr_ret_stack;
+}
+
+static inline void pause_graph_tracing(void)
+{
+        atomic_inc(&current->tracing_graph_pause);
+}
+
+static inline void unpause_graph_tracing(void)
+{
+        atomic_dec(&current->tracing_graph_pause);
+}
 #else
-static inline void trace_boot(struct boot_trace *it, initcall_t fn) { }
-static inline void start_boot_trace(void) { }
-static inline void stop_boot_trace(void) { }
+
+#define __notrace_funcgraph
+#define __irq_entry
+
+static inline void ftrace_graph_init_task(struct task_struct *t) { }
+static inline void ftrace_graph_exit_task(struct task_struct *t) { }
+
+static inline int task_curr_ret_stack(struct task_struct *tsk)
+{
+        return -1;
+}
+
+static inline void pause_graph_tracing(void) { }
+static inline void unpause_graph_tracing(void) { }
 #endif
 
+#ifdef CONFIG_TRACING
+#include <linux/sched.h>
+
+/* flags for current->trace */
+enum {
+        TSK_TRACE_FL_TRACE_BIT  = 0,
+        TSK_TRACE_FL_GRAPH_BIT  = 1,
+};
+enum {
+        TSK_TRACE_FL_TRACE      = 1 << TSK_TRACE_FL_TRACE_BIT,
+        TSK_TRACE_FL_GRAPH      = 1 << TSK_TRACE_FL_GRAPH_BIT,
+};
+
+static inline void set_tsk_trace_trace(struct task_struct *tsk)
+{
+        set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
+}
+
+static inline void clear_tsk_trace_trace(struct task_struct *tsk)
+{
+        clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
+}
+
+static inline int test_tsk_trace_trace(struct task_struct *tsk)
+{
+        return tsk->trace & TSK_TRACE_FL_TRACE;
+}
+
+static inline void set_tsk_trace_graph(struct task_struct *tsk)
+{
+        set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
+}
+
+static inline void clear_tsk_trace_graph(struct task_struct *tsk)
+{
+        clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
+}
+
+static inline int test_tsk_trace_graph(struct task_struct *tsk)
+{
+        return tsk->trace & TSK_TRACE_FL_GRAPH;
+}
 
+#endif /* CONFIG_TRACING */
 
 #endif /* _LINUX_FTRACE_H */
diff --git a/include/linux/ftrace_irq.h b/include/linux/ftrace_irq.h
new file mode 100644
index 000000000000..366a054d0b05
--- /dev/null
+++ b/include/linux/ftrace_irq.h
@@ -0,0 +1,13 @@
+#ifndef _LINUX_FTRACE_IRQ_H
+#define _LINUX_FTRACE_IRQ_H
+
+
+#if defined(CONFIG_DYNAMIC_FTRACE) || defined(CONFIG_FUNCTION_GRAPH_TRACER)
+extern void ftrace_nmi_enter(void);
+extern void ftrace_nmi_exit(void);
+#else
+static inline void ftrace_nmi_enter(void) { }
+static inline void ftrace_nmi_exit(void) { }
+#endif
+
+#endif /* _LINUX_FTRACE_IRQ_H */
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index 181006cc94a0..89a56d79e4c6 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -4,6 +4,7 @@
 #include <linux/preempt.h>
 #include <linux/smp_lock.h>
 #include <linux/lockdep.h>
+#include <linux/ftrace_irq.h>
 #include <asm/hardirq.h>
 #include <asm/system.h>
 
@@ -161,7 +162,17 @@ extern void irq_enter(void);
  */
 extern void irq_exit(void);
 
-#define nmi_enter()             do { lockdep_off(); __irq_enter(); } while (0)
-#define nmi_exit()              do { __irq_exit(); lockdep_on(); } while (0)
+#define nmi_enter()                             \
+        do {                                    \
+                ftrace_nmi_enter();             \
+                lockdep_off();                  \
+                __irq_enter();                  \
+        } while (0)
+#define nmi_exit()                              \
+        do {                                    \
+                __irq_exit();                   \
+                lockdep_on();                   \
+                ftrace_nmi_exit();              \
+        } while (0)
 
 #endif /* LINUX_HARDIRQ_H */
diff --git a/include/linux/marker.h b/include/linux/marker.h
index 889196c7fbb1..b85e74ca782f 100644
--- a/include/linux/marker.h
+++ b/include/linux/marker.h
@@ -12,6 +12,7 @@
  * See the file COPYING for more details.
  */
 
+#include <stdarg.h>
 #include <linux/types.h>
 
 struct module;
@@ -48,10 +49,28 @@ struct marker {
         void (*call)(const struct marker *mdata, void *call_private, ...);
         struct marker_probe_closure single;
         struct marker_probe_closure *multi;
+        const char *tp_name;    /* Optional tracepoint name */
+        void *tp_cb;            /* Optional tracepoint callback */
 } __attribute__((aligned(8)));
 
 #ifdef CONFIG_MARKERS
 
+#define _DEFINE_MARKER(name, tp_name_str, tp_cb, format)                \
+                static const char __mstrtab_##name[]                    \
+                __attribute__((section("__markers_strings")))           \
+                = #name "\0" format;                                    \
+                static struct marker __mark_##name                      \
+                __attribute__((section("__markers"), aligned(8))) =     \
+                { __mstrtab_##name, &__mstrtab_##name[sizeof(#name)],   \
+                  0, 0, marker_probe_cb, { __mark_empty_function, NULL},\
+                  NULL, tp_name_str, tp_cb }
+
+#define DEFINE_MARKER(name, format)                                     \
+                _DEFINE_MARKER(name, NULL, NULL, format)
+
+#define DEFINE_MARKER_TP(name, tp_name, tp_cb, format)                  \
+                _DEFINE_MARKER(name, #tp_name, tp_cb, format)
+
 /*
  * Note : the empty asm volatile with read constraint is used here instead of a
  * "used" attribute to fix a gcc 4.1.x bug.
@@ -65,14 +84,7 @@ struct marker {
  */
 #define __trace_mark(generic, name, call_private, format, args...)      \
         do {                                                            \
-                static const char __mstrtab_##name[]                    \
-                __attribute__((section("__markers_strings")))           \
-                = #name "\0" format;                                    \
-                static struct marker __mark_##name                      \
-                __attribute__((section("__markers"), aligned(8))) =     \
-                { __mstrtab_##name, &__mstrtab_##name[sizeof(#name)],   \
-                0, 0, marker_probe_cb,                                  \
-                { __mark_empty_function, NULL}, NULL };                 \
+                DEFINE_MARKER(name, format);                            \
                 __mark_check_format(format, ## args);                   \
                 if (unlikely(__mark_##name.state)) {                    \
                         (*__mark_##name.call)                           \
@@ -80,14 +92,39 @@ struct marker {
                 }                                                       \
         } while (0)
 
+#define __trace_mark_tp(name, call_private, tp_name, tp_cb, format, args...) \
+        do {                                                            \
+                void __check_tp_type(void)                              \
+                {                                                       \
+                        register_trace_##tp_name(tp_cb);                \
+                }                                                       \
+                DEFINE_MARKER_TP(name, tp_name, tp_cb, format);         \
+                __mark_check_format(format, ## args);                   \
+                (*__mark_##name.call)(&__mark_##name, call_private,     \
+                                        ## args);                       \
+        } while (0)
+
 extern void marker_update_probe_range(struct marker *begin,
         struct marker *end);
+
+#define GET_MARKER(name)        (__mark_##name)
+
 #else /* !CONFIG_MARKERS */
+#define DEFINE_MARKER(name, tp_name, tp_cb, format)
 #define __trace_mark(generic, name, call_private, format, args...) \
                 __mark_check_format(format, ## args)
+#define __trace_mark_tp(name, call_private, tp_name, tp_cb, format, args...) \
+        do {                                                            \
+                void __check_tp_type(void)                              \
+                {                                                       \
+                        register_trace_##tp_name(tp_cb);                \
+                }                                                       \
+                __mark_check_format(format, ## args);                   \
+        } while (0)
 static inline void marker_update_probe_range(struct marker *begin,
         struct marker *end)
 { }
+#define GET_MARKER(name)
 #endif /* CONFIG_MARKERS */
 
 /**
@@ -117,6 +154,20 @@ static inline void marker_update_probe_range(struct marker *begin,
         __trace_mark(1, name, NULL, format, ## args)
 
 /**
+ * trace_mark_tp - Marker in a tracepoint callback
+ * @name: marker name, not quoted.
+ * @tp_name: tracepoint name, not quoted.
+ * @tp_cb: tracepoint callback. Should have an associated global symbol so it
+ *         is not optimized away by the compiler (should not be static).
+ * @format: format string
+ * @args...: variable argument list
+ *
+ * Places a marker in a tracepoint callback.
+ */
+#define trace_mark_tp(name, tp_name, tp_cb, format, args...)    \
+        __trace_mark_tp(name, NULL, tp_name, tp_cb, format, ## args)
+
+/**
  * MARK_NOARGS - Format string for a marker with no argument.
  */
 #define MARK_NOARGS " "
@@ -136,8 +187,6 @@ extern marker_probe_func __mark_empty_function;
 
 extern void marker_probe_cb(const struct marker *mdata,
         void *call_private, ...);
-extern void marker_probe_cb_noarg(const struct marker *mdata,
-        void *call_private, ...);
 
 /*
  * Connect a probe to a marker.
@@ -162,8 +211,10 @@ extern void *marker_get_private_data(const char *name, marker_probe_func *probe,
 
 /*
  * marker_synchronize_unregister must be called between the last marker probe
- * unregistration and the end of module exit to make sure there is no caller
- * executing a probe when it is freed.
+ * unregistration and the first one of
+ * - the end of module exit function
+ * - the free of any resource used by the probes
+ * to ensure the code and data are valid for any possibly running probes.
  */
 #define marker_synchronize_unregister() synchronize_sched()
 
diff --git a/include/linux/mm.h b/include/linux/mm.h
index d3ddd735e375..aaa8b843be28 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1305,5 +1305,7 @@ int vmemmap_populate_basepages(struct page *start_page,
 int vmemmap_populate(struct page *start_page, unsigned long pages, int node);
 void vmemmap_populate_print_last(void);
 
+extern void *alloc_locked_buffer(size_t size);
+extern void free_locked_buffer(void *buffer, size_t size);
 #endif /* __KERNEL__ */
 #endif /* _LINUX_MM_H */
diff --git a/include/linux/pid.h b/include/linux/pid.h
index d7e98ff8021e..bb206c56d1f0 100644
--- a/include/linux/pid.h
+++ b/include/linux/pid.h
@@ -147,9 +147,9 @@ pid_t pid_vnr(struct pid *pid);
 #define do_each_pid_task(pid, type, task)                               \
         do {                                                            \
                 struct hlist_node *pos___;                              \
-                if (pid != NULL)                                        \
+                if ((pid) != NULL)                                      \
                         hlist_for_each_entry_rcu((task), pos___,        \
-                                &pid->tasks[type], pids[type].node) {
+                                &(pid)->tasks[type], pids[type].node) {
 
                         /*
                          * Both old and new leaders may be attached to
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index 22641d5d45df..98b93ca4db06 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -94,6 +94,7 @@ extern void ptrace_notify(int exit_code);
 extern void __ptrace_link(struct task_struct *child,
                           struct task_struct *new_parent);
 extern void __ptrace_unlink(struct task_struct *child);
+extern void ptrace_fork(struct task_struct *task, unsigned long clone_flags);
 #define PTRACE_MODE_READ   1
 #define PTRACE_MODE_ATTACH 2
 /* Returns 0 on success, -errno on denial. */
@@ -313,6 +314,27 @@ static inline void user_enable_block_step(struct task_struct *task)
 #define arch_ptrace_stop(code, info)            do { } while (0)
 #endif
 
+#ifndef arch_ptrace_untrace
+/*
+ * Do machine-specific work before untracing child.
+ *
+ * This is called for a normal detach as well as from ptrace_exit()
+ * when the tracing task dies.
+ *
+ * Called with write_lock(&tasklist_lock) held.
+ */
+#define arch_ptrace_untrace(task)               do { } while (0)
+#endif
+
+#ifndef arch_ptrace_fork
+/*
+ * Do machine-specific work to initialize a new task.
+ *
+ * This is called from copy_process().
+ */
+#define arch_ptrace_fork(child, clone_flags)    do { } while (0)
+#endif
+
 extern int task_current_syscall(struct task_struct *target, long *callno,
                                 unsigned long args[6], unsigned int maxargs,
                                 unsigned long *sp, unsigned long *pc);
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 86f1f5e43e33..895dc9c1088c 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -142,6 +142,7 @@ struct rcu_head {
  * on the write-side to insure proper synchronization.
  */
 #define rcu_read_lock_sched() preempt_disable()
+#define rcu_read_lock_sched_notrace() preempt_disable_notrace()
 
 /*
  * rcu_read_unlock_sched - marks the end of a RCU-classic critical section
@@ -149,6 +150,7 @@ struct rcu_head {
  * See rcu_read_lock_sched for more information.
  */
 #define rcu_read_unlock_sched() preempt_enable()
+#define rcu_read_unlock_sched_notrace() preempt_enable_notrace()
 
 
 
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index e097c2e6b6dc..d363467c8f13 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -28,17 +28,19 @@ struct ring_buffer_event {
  *                               size = 8 bytes
  *
  * @RINGBUF_TYPE_TIME_STAMP:    Sync time stamp with external clock
- *                               array[0] = tv_nsec
- *                               array[1] = tv_sec
+ *                               array[0]    = tv_nsec
+ *                               array[1..2] = tv_sec
  *                               size = 16 bytes
  *
  * @RINGBUF_TYPE_DATA:          Data record
  *                               If len is zero:
  *                                array[0] holds the actual length
- *                                array[1..(length+3)/4-1] holds data
+ *                                array[1..(length+3)/4] holds data
+ *                                size = 4 + 4 + length (bytes)
  *                               else
  *                                length = len << 2
- *                                array[0..(length+3)/4] holds data
+ *                                array[0..(length+3)/4-1] holds data
+ *                                size = 4 + length (bytes)
  */
 enum ring_buffer_type {
         RINGBUF_TYPE_PADDING,
@@ -122,6 +124,12 @@ void ring_buffer_normalize_time_stamp(int cpu, u64 *ts);
 
 void tracing_on(void);
 void tracing_off(void);
+void tracing_off_permanent(void);
+
+void *ring_buffer_alloc_read_page(struct ring_buffer *buffer);
+void ring_buffer_free_read_page(struct ring_buffer *buffer, void *data);
+int ring_buffer_read_page(struct ring_buffer *buffer,
+                          void **data_page, int cpu, int full);
 
 enum ring_buffer_flags {
         RB_FL_OVERWRITE         = 1 << 0,
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 9624e2cfc2dc..0a1094d84b77 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -96,6 +96,7 @@ struct exec_domain;
 struct futex_pi_state;
 struct robust_list_head;
 struct bio;
+struct bts_tracer;
 
 /*
  * List of flags we want to share for kernel threads,
@@ -1130,6 +1131,19 @@ struct task_struct {
         struct list_head ptraced;
         struct list_head ptrace_entry;
 
+#ifdef CONFIG_X86_PTRACE_BTS
+        /*
+         * This is the tracer handle for the ptrace BTS extension.
+         * This field actually belongs to the ptracer task.
+         */
+        struct bts_tracer *bts;
+        /*
+         * The buffer to hold the BTS data.
+         */
+        void *bts_buffer;
+        size_t bts_size;
+#endif /* CONFIG_X86_PTRACE_BTS */
+
         /* PID/PID hash table linkage. */
         struct pid_link pids[PIDTYPE_MAX];
         struct list_head thread_group;
@@ -1313,6 +1327,23 @@ struct task_struct {
         unsigned long default_timer_slack_ns;
 
         struct list_head        *scm_work_list;
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+        /* Index of current stored adress in ret_stack */
+        int curr_ret_stack;
+        /* Stack of return addresses for return function tracing */
+        struct ftrace_ret_stack *ret_stack;
+        /*
+         * Number of functions that haven't been traced
+         * because of depth overrun.
+         */
+        atomic_t trace_overrun;
+        /* Pause for the tracing */
+        atomic_t tracing_graph_pause;
+#endif
+#ifdef CONFIG_TRACING
+        /* state flags for use by tracers */
+        unsigned long trace;
+#endif
 };
 
 /*
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index dc50bcc282a8..b3dfa72f13b9 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -34,6 +34,7 @@ struct seq_operations {
 
 #define SEQ_SKIP 1
 
+char *mangle_path(char *s, char *p, char *esc);
 int seq_open(struct file *, const struct seq_operations *);
 ssize_t seq_read(struct file *, char __user *, size_t, loff_t *);
 loff_t seq_lseek(struct file *, loff_t, int);
diff --git a/include/linux/stacktrace.h b/include/linux/stacktrace.h
index b106fd8e0d5c..1a8cecc4f38c 100644
--- a/include/linux/stacktrace.h
+++ b/include/linux/stacktrace.h
@@ -15,9 +15,17 @@ extern void save_stack_trace_tsk(struct task_struct *tsk,
                                 struct stack_trace *trace);
 
 extern void print_stack_trace(struct stack_trace *trace, int spaces);
+
+#ifdef CONFIG_USER_STACKTRACE_SUPPORT
+extern void save_stack_trace_user(struct stack_trace *trace);
+#else
+# define save_stack_trace_user(trace)              do { } while (0)
+#endif
+
 #else
 # define save_stack_trace(trace)                        do { } while (0)
 # define save_stack_trace_tsk(tsk, trace)               do { } while (0)
+# define save_stack_trace_user(trace)                   do { } while (0)
 # define print_stack_trace(trace, spaces)               do { } while (0)
 #endif
 
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index c5bb39c7a770..757005458366 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -24,8 +24,12 @@ struct tracepoint {
         const char *name;               /* Tracepoint name */
         int state;                      /* State. */
         void **funcs;
-} __attribute__((aligned(8)));
-
+} __attribute__((aligned(32)));         /*
+                                         * Aligned on 32 bytes because it is
+                                         * globally visible and gcc happily
+                                         * align these on the structure size.
+                                         * Keep in sync with vmlinux.lds.h.
+                                         */
 
 #define TPPROTO(args...)        args
 #define TPARGS(args...)         args
@@ -40,14 +44,14 @@ struct tracepoint {
         do {                                                            \
                 void **it_func;                                         \
                                                                         \
-                rcu_read_lock_sched();                                  \
+                rcu_read_lock_sched_notrace();                          \
                 it_func = rcu_dereference((tp)->funcs);                 \
                 if (it_func) {                                          \
                         do {                                            \
                                 ((void(*)(proto))(*it_func))(args);     \
                         } while (*(++it_func));                         \
                 }                                                       \
-                rcu_read_unlock_sched();                                \
+                rcu_read_unlock_sched_notrace();                        \
         } while (0)
 
 /*
@@ -55,35 +59,40 @@ struct tracepoint {
  * not add unwanted padding between the beginning of the section and the
  * structure. Force alignment to the same alignment as the section start.
  */
-#define DEFINE_TRACE(name, proto, args)                                 \
+#define DECLARE_TRACE(name, proto, args)                                \
+        extern struct tracepoint __tracepoint_##name;                   \
         static inline void trace_##name(proto)                          \
         {                                                               \
-                static const char __tpstrtab_##name[]                   \
-                __attribute__((section("__tracepoints_strings")))       \
-                = #name ":" #proto;                                     \
-                static struct tracepoint __tracepoint_##name            \
-                __attribute__((section("__tracepoints"), aligned(8))) = \
-                { __tpstrtab_##name, 0, NULL };                         \
                 if (unlikely(__tracepoint_##name.state))                \
                         __DO_TRACE(&__tracepoint_##name,                \
                                 TPPROTO(proto), TPARGS(args));          \
         }                                                               \
         static inline int register_trace_##name(void (*probe)(proto))   \
         {                                                               \
-                return tracepoint_probe_register(#name ":" #proto,      \
-                        (void *)probe);                                 \
+                return tracepoint_probe_register(#name, (void *)probe); \
         }                                                               \
-        static inline void unregister_trace_##name(void (*probe)(proto))\
+        static inline int unregister_trace_##name(void (*probe)(proto)) \
         {                                                               \
-                tracepoint_probe_unregister(#name ":" #proto,           \
-                        (void *)probe);                                 \
+                return tracepoint_probe_unregister(#name, (void *)probe);\
         }
 
+#define DEFINE_TRACE(name)                                              \
+        static const char __tpstrtab_##name[]                           \
+        __attribute__((section("__tracepoints_strings"))) = #name;      \
+        struct tracepoint __tracepoint_##name                           \
+        __attribute__((section("__tracepoints"), aligned(32))) =        \
+                { __tpstrtab_##name, 0, NULL }
+
+#define EXPORT_TRACEPOINT_SYMBOL_GPL(name)                              \
+        EXPORT_SYMBOL_GPL(__tracepoint_##name)
+#define EXPORT_TRACEPOINT_SYMBOL(name)                                  \
+        EXPORT_SYMBOL(__tracepoint_##name)
+
 extern void tracepoint_update_probe_range(struct tracepoint *begin,
         struct tracepoint *end);
 
 #else /* !CONFIG_TRACEPOINTS */
-#define DEFINE_TRACE(name, proto, args)                 \
+#define DECLARE_TRACE(name, proto, args)                                \
         static inline void _do_trace_##name(struct tracepoint *tp, proto) \
         { }                                                             \
         static inline void trace_##name(proto)                          \
@@ -92,8 +101,14 @@ extern void tracepoint_update_probe_range(struct tracepoint *begin,
         {                                                               \
                 return -ENOSYS;                                         \
         }                                                               \
-        static inline void unregister_trace_##name(void (*probe)(proto))\
-        { }
+        static inline int unregister_trace_##name(void (*probe)(proto)) \
+        {                                                               \
+                return -ENOSYS;                                         \
+        }
+
+#define DEFINE_TRACE(name)
+#define EXPORT_TRACEPOINT_SYMBOL_GPL(name)
+#define EXPORT_TRACEPOINT_SYMBOL(name)
 
 static inline void tracepoint_update_probe_range(struct tracepoint *begin,
         struct tracepoint *end)
@@ -112,6 +127,10 @@ extern int tracepoint_probe_register(const char *name, void *probe);
  */
 extern int tracepoint_probe_unregister(const char *name, void *probe);
 
+extern int tracepoint_probe_register_noupdate(const char *name, void *probe);
+extern int tracepoint_probe_unregister_noupdate(const char *name, void *probe);
+extern void tracepoint_probe_update_all(void);
+
 struct tracepoint_iter {
         struct module *module;
         struct tracepoint *tracepoint;
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 580700f20a1c..3f4954c55e53 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -325,7 +325,7 @@ extern struct class *tty_class;
  *      go away
  */
 
-extern inline struct tty_struct *tty_kref_get(struct tty_struct *tty)
+static inline struct tty_struct *tty_kref_get(struct tty_struct *tty)
 {
         if (tty)
                 kref_get(&tty->kref);