10 files changed, 408 insertions, 109 deletions

diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index 2902657ba766..f18b3b76e01e 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -42,6 +42,7 @@ struct extent_buffer;
                 { BTRFS_TREE_LOG_OBJECTID,      "TREE_LOG"      },      \
                 { BTRFS_QUOTA_TREE_OBJECTID,    "QUOTA_TREE"    },      \
                 { BTRFS_TREE_RELOC_OBJECTID,    "TREE_RELOC"    },      \
+                { BTRFS_UUID_TREE_OBJECTID,     "UUID_RELOC"    },      \
                 { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" })
 
 #define show_root_type(obj)                                             \
@@ -439,7 +440,7 @@ TRACE_EVENT(btrfs_sync_fs,
                 { BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" })
                         
 
-TRACE_EVENT(btrfs_delayed_tree_ref,
+DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref,
 
         TP_PROTO(struct btrfs_delayed_ref_node *ref,
                  struct btrfs_delayed_tree_ref *full_ref,
@@ -481,7 +482,25 @@ TRACE_EVENT(btrfs_delayed_tree_ref,
                   (unsigned long long)__entry->seq)
 );
 
-TRACE_EVENT(btrfs_delayed_data_ref,
+DEFINE_EVENT(btrfs_delayed_tree_ref,  add_delayed_tree_ref,
+
+        TP_PROTO(struct btrfs_delayed_ref_node *ref,
+                 struct btrfs_delayed_tree_ref *full_ref,
+                 int action),
+
+        TP_ARGS(ref, full_ref, action)
+);
+
+DEFINE_EVENT(btrfs_delayed_tree_ref,  run_delayed_tree_ref,
+
+        TP_PROTO(struct btrfs_delayed_ref_node *ref,
+                 struct btrfs_delayed_tree_ref *full_ref,
+                 int action),
+
+        TP_ARGS(ref, full_ref, action)
+);
+
+DECLARE_EVENT_CLASS(btrfs_delayed_data_ref,
 
         TP_PROTO(struct btrfs_delayed_ref_node *ref,
                  struct btrfs_delayed_data_ref *full_ref,
@@ -527,7 +546,25 @@ TRACE_EVENT(btrfs_delayed_data_ref,
                   (unsigned long long)__entry->seq)
 );
 
-TRACE_EVENT(btrfs_delayed_ref_head,
+DEFINE_EVENT(btrfs_delayed_data_ref,  add_delayed_data_ref,
+
+        TP_PROTO(struct btrfs_delayed_ref_node *ref,
+                 struct btrfs_delayed_data_ref *full_ref,
+                 int action),
+
+        TP_ARGS(ref, full_ref, action)
+);
+
+DEFINE_EVENT(btrfs_delayed_data_ref,  run_delayed_data_ref,
+
+        TP_PROTO(struct btrfs_delayed_ref_node *ref,
+                 struct btrfs_delayed_data_ref *full_ref,
+                 int action),
+
+        TP_ARGS(ref, full_ref, action)
+);
+
+DECLARE_EVENT_CLASS(btrfs_delayed_ref_head,
 
         TP_PROTO(struct btrfs_delayed_ref_node *ref,
                  struct btrfs_delayed_ref_head *head_ref,
@@ -556,6 +593,24 @@ TRACE_EVENT(btrfs_delayed_ref_head,
                   __entry->is_data)
 );
 
+DEFINE_EVENT(btrfs_delayed_ref_head,  add_delayed_ref_head,
+
+        TP_PROTO(struct btrfs_delayed_ref_node *ref,
+                 struct btrfs_delayed_ref_head *head_ref,
+                 int action),
+
+        TP_ARGS(ref, head_ref, action)
+);
+
+DEFINE_EVENT(btrfs_delayed_ref_head,  run_delayed_ref_head,
+
+        TP_PROTO(struct btrfs_delayed_ref_node *ref,
+                 struct btrfs_delayed_ref_head *head_ref,
+                 int action),
+
+        TP_ARGS(ref, head_ref, action)
+);
+
 #define show_chunk_type(type)                                   \
         __print_flags(type, "|",                                \
                 { BTRFS_BLOCK_GROUP_DATA,       "DATA"  },      \
diff --git a/include/trace/events/context_tracking.h b/include/trace/events/context_tracking.h
new file mode 100644
index 000000000000..ce8007cf29cf
--- /dev/null
+++ b/include/trace/events/context_tracking.h
@@ -0,0 +1,58 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM context_tracking
+
+#if !defined(_TRACE_CONTEXT_TRACKING_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_CONTEXT_TRACKING_H
+
+#include <linux/tracepoint.h>
+
+DECLARE_EVENT_CLASS(context_tracking_user,
+
+        TP_PROTO(int dummy),
+
+        TP_ARGS(dummy),
+
+        TP_STRUCT__entry(
+                __field( int,   dummy   )
+        ),
+
+        TP_fast_assign(
+                __entry->dummy          = dummy;
+        ),
+
+        TP_printk("%s", "")
+);
+
+/**
+ * user_enter - called when the kernel resumes to userspace
+ * @dummy:      dummy arg to make trace event macro happy
+ *
+ * This event occurs when the kernel resumes to userspace  after
+ * an exception or a syscall.
+ */
+DEFINE_EVENT(context_tracking_user, user_enter,
+
+        TP_PROTO(int dummy),
+
+        TP_ARGS(dummy)
+);
+
+/**
+ * user_exit - called when userspace enters the kernel
+ * @dummy:      dummy arg to make trace event macro happy
+ *
+ * This event occurs when userspace enters the kernel through
+ * an exception or a syscall.
+ */
+DEFINE_EVENT(context_tracking_user, user_exit,
+
+        TP_PROTO(int dummy),
+
+        TP_ARGS(dummy)
+);
+
+
+#endif /*  _TRACE_CONTEXT_TRACKING_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h
index 2068db241f22..197d3125df2a 100644
--- a/include/trace/events/ext4.h
+++ b/include/trace/events/ext4.h
@@ -14,7 +14,6 @@ struct ext4_prealloc_space;
 struct ext4_inode_info;
 struct mpage_da_data;
 struct ext4_map_blocks;
-struct ext4_extent;
 struct extent_status;
 
 #define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode))
@@ -64,10 +63,10 @@ struct extent_status;
         { EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER, "LAST_CLUSTER" })
 
 #define show_extent_status(status) __print_flags(status, "",    \
-        { (1 << 3),     "W" },                                  \
-        { (1 << 2),     "U" },                                  \
-        { (1 << 1),     "D" },                                  \
-        { (1 << 0),     "H" })
+        { EXTENT_STATUS_WRITTEN,        "W" },                  \
+        { EXTENT_STATUS_UNWRITTEN,      "U" },                  \
+        { EXTENT_STATUS_DELAYED,        "D" },                  \
+        { EXTENT_STATUS_HOLE,           "H" })
 
 
 TRACE_EVENT(ext4_free_inode,
@@ -2192,7 +2191,7 @@ TRACE_EVENT(ext4_ext_remove_space_done,
                   (unsigned short) __entry->eh_entries)
 );
 
-TRACE_EVENT(ext4_es_insert_extent,
+DECLARE_EVENT_CLASS(ext4__es_extent,
         TP_PROTO(struct inode *inode, struct extent_status *es),
 
         TP_ARGS(inode, es),
@@ -2212,7 +2211,7 @@ TRACE_EVENT(ext4_es_insert_extent,
                 __entry->lblk   = es->es_lblk;
                 __entry->len    = es->es_len;
                 __entry->pblk   = ext4_es_pblock(es);
-                __entry->status = ext4_es_status(es) >> 60;
+                __entry->status = ext4_es_status(es);
         ),
 
         TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
@@ -2222,6 +2221,18 @@ TRACE_EVENT(ext4_es_insert_extent,
                   __entry->pblk, show_extent_status(__entry->status))
 );
 
+DEFINE_EVENT(ext4__es_extent, ext4_es_insert_extent,
+        TP_PROTO(struct inode *inode, struct extent_status *es),
+
+        TP_ARGS(inode, es)
+);
+
+DEFINE_EVENT(ext4__es_extent, ext4_es_cache_extent,
+        TP_PROTO(struct inode *inode, struct extent_status *es),
+
+        TP_ARGS(inode, es)
+);
+
 TRACE_EVENT(ext4_es_remove_extent,
         TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_lblk_t len),
 
@@ -2289,7 +2300,7 @@ TRACE_EVENT(ext4_es_find_delayed_extent_range_exit,
                 __entry->lblk   = es->es_lblk;
                 __entry->len    = es->es_len;
                 __entry->pblk   = ext4_es_pblock(es);
-                __entry->status = ext4_es_status(es) >> 60;
+                __entry->status = ext4_es_status(es);
         ),
 
         TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
@@ -2343,7 +2354,7 @@ TRACE_EVENT(ext4_es_lookup_extent_exit,
                 __entry->lblk   = es->es_lblk;
                 __entry->len    = es->es_len;
                 __entry->pblk   = ext4_es_pblock(es);
-                __entry->status = ext4_es_status(es) >> 60;
+                __entry->status = ext4_es_status(es);
                 __entry->found  = found;
         ),
 
diff --git a/include/trace/events/kmem.h b/include/trace/events/kmem.h
index 6bc943ecb841..d0c613476620 100644
--- a/include/trace/events/kmem.h
+++ b/include/trace/events/kmem.h
@@ -268,11 +268,13 @@ TRACE_EVENT(mm_page_alloc_extfrag,
 
         TP_PROTO(struct page *page,
                         int alloc_order, int fallback_order,
-                        int alloc_migratetype, int fallback_migratetype),
+                        int alloc_migratetype, int fallback_migratetype,
+                        int change_ownership),
 
         TP_ARGS(page,
                 alloc_order, fallback_order,
-                alloc_migratetype, fallback_migratetype),
+                alloc_migratetype, fallback_migratetype,
+                change_ownership),
 
         TP_STRUCT__entry(
                 __field(        struct page *,  page                    )
@@ -280,6 +282,7 @@ TRACE_EVENT(mm_page_alloc_extfrag,
                 __field(        int,            fallback_order          )
                 __field(        int,            alloc_migratetype       )
                 __field(        int,            fallback_migratetype    )
+                __field(        int,            change_ownership        )
         ),
 
         TP_fast_assign(
@@ -288,6 +291,7 @@ TRACE_EVENT(mm_page_alloc_extfrag,
                 __entry->fallback_order         = fallback_order;
                 __entry->alloc_migratetype      = alloc_migratetype;
                 __entry->fallback_migratetype   = fallback_migratetype;
+                __entry->change_ownership       = change_ownership;
         ),
 
         TP_printk("page=%p pfn=%lu alloc_order=%d fallback_order=%d pageblock_order=%d alloc_migratetype=%d fallback_migratetype=%d fragmenting=%d change_ownership=%d",
@@ -299,7 +303,7 @@ TRACE_EVENT(mm_page_alloc_extfrag,
                 __entry->alloc_migratetype,
                 __entry->fallback_migratetype,
                 __entry->fallback_order < pageblock_order,
-                __entry->alloc_migratetype == __entry->fallback_migratetype)
+                __entry->change_ownership)
 );
 
 #endif /* _TRACE_KMEM_H */
diff --git a/include/trace/events/power.h b/include/trace/events/power.h
index 8e42410bd159..cda100d6762d 100644
--- a/include/trace/events/power.h
+++ b/include/trace/events/power.h
@@ -66,6 +66,43 @@ TRACE_EVENT(machine_suspend,
         TP_printk("state=%lu", (unsigned long)__entry->state)
 );
 
+TRACE_EVENT(device_pm_report_time,
+
+        TP_PROTO(struct device *dev, const char *pm_ops, s64 ops_time,
+                 char *pm_event_str, int error),
+
+        TP_ARGS(dev, pm_ops, ops_time, pm_event_str, error),
+
+        TP_STRUCT__entry(
+                __string(device, dev_name(dev))
+                __string(driver, dev_driver_string(dev))
+                __string(parent, dev->parent ? dev_name(dev->parent) : "none")
+                __string(pm_ops, pm_ops ? pm_ops : "none ")
+                __string(pm_event_str, pm_event_str)
+                __field(s64, ops_time)
+                __field(int, error)
+        ),
+
+        TP_fast_assign(
+                const char *tmp = dev->parent ? dev_name(dev->parent) : "none";
+                const char *tmp_i = pm_ops ? pm_ops : "none ";
+
+                __assign_str(device, dev_name(dev));
+                __assign_str(driver, dev_driver_string(dev));
+                __assign_str(parent, tmp);
+                __assign_str(pm_ops, tmp_i);
+                __assign_str(pm_event_str, pm_event_str);
+                __entry->ops_time = ops_time;
+                __entry->error = error;
+        ),
+
+        /* ops_str has an extra space at the end */
+        TP_printk("%s %s parent=%s state=%s ops=%snsecs=%lld err=%d",
+                __get_str(driver), __get_str(device), __get_str(parent),
+                __get_str(pm_event_str), __get_str(pm_ops),
+                __entry->ops_time, __entry->error)
+);
+
 DECLARE_EVENT_CLASS(wakeup_source,
 
         TP_PROTO(const char *name, unsigned int state),
diff --git a/include/trace/events/rcu.h b/include/trace/events/rcu.h
index 59ebcc89f148..ee2376cfaab3 100644
--- a/include/trace/events/rcu.h
+++ b/include/trace/events/rcu.h
@@ -19,12 +19,12 @@
  */
 TRACE_EVENT(rcu_utilization,
 
-        TP_PROTO(char *s),
+        TP_PROTO(const char *s),
 
         TP_ARGS(s),
 
         TP_STRUCT__entry(
-                __field(char *, s)
+                __field(const char *, s)
         ),
 
         TP_fast_assign(
@@ -51,14 +51,14 @@ TRACE_EVENT(rcu_utilization,
  */
 TRACE_EVENT(rcu_grace_period,
 
-        TP_PROTO(char *rcuname, unsigned long gpnum, char *gpevent),
+        TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent),
 
         TP_ARGS(rcuname, gpnum, gpevent),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(unsigned long, gpnum)
-                __field(char *, gpevent)
+                __field(const char *, gpevent)
         ),
 
         TP_fast_assign(
@@ -89,21 +89,21 @@ TRACE_EVENT(rcu_grace_period,
  */
 TRACE_EVENT(rcu_future_grace_period,
 
-        TP_PROTO(char *rcuname, unsigned long gpnum, unsigned long completed,
+        TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed,
                  unsigned long c, u8 level, int grplo, int grphi,
-                 char *gpevent),
+                 const char *gpevent),
 
         TP_ARGS(rcuname, gpnum, completed, c, level, grplo, grphi, gpevent),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(unsigned long, gpnum)
                 __field(unsigned long, completed)
                 __field(unsigned long, c)
                 __field(u8, level)
                 __field(int, grplo)
                 __field(int, grphi)
-                __field(char *, gpevent)
+                __field(const char *, gpevent)
         ),
 
         TP_fast_assign(
@@ -132,13 +132,13 @@ TRACE_EVENT(rcu_future_grace_period,
  */
 TRACE_EVENT(rcu_grace_period_init,
 
-        TP_PROTO(char *rcuname, unsigned long gpnum, u8 level,
+        TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level,
                  int grplo, int grphi, unsigned long qsmask),
 
         TP_ARGS(rcuname, gpnum, level, grplo, grphi, qsmask),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(unsigned long, gpnum)
                 __field(u8, level)
                 __field(int, grplo)
@@ -168,12 +168,12 @@ TRACE_EVENT(rcu_grace_period_init,
  */
 TRACE_EVENT(rcu_preempt_task,
 
-        TP_PROTO(char *rcuname, int pid, unsigned long gpnum),
+        TP_PROTO(const char *rcuname, int pid, unsigned long gpnum),
 
         TP_ARGS(rcuname, pid, gpnum),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(unsigned long, gpnum)
                 __field(int, pid)
         ),
@@ -195,12 +195,12 @@ TRACE_EVENT(rcu_preempt_task,
  */
 TRACE_EVENT(rcu_unlock_preempted_task,
 
-        TP_PROTO(char *rcuname, unsigned long gpnum, int pid),
+        TP_PROTO(const char *rcuname, unsigned long gpnum, int pid),
 
         TP_ARGS(rcuname, gpnum, pid),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(unsigned long, gpnum)
                 __field(int, pid)
         ),
@@ -224,14 +224,14 @@ TRACE_EVENT(rcu_unlock_preempted_task,
  */
 TRACE_EVENT(rcu_quiescent_state_report,
 
-        TP_PROTO(char *rcuname, unsigned long gpnum,
+        TP_PROTO(const char *rcuname, unsigned long gpnum,
                  unsigned long mask, unsigned long qsmask,
                  u8 level, int grplo, int grphi, int gp_tasks),
 
         TP_ARGS(rcuname, gpnum, mask, qsmask, level, grplo, grphi, gp_tasks),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(unsigned long, gpnum)
                 __field(unsigned long, mask)
                 __field(unsigned long, qsmask)
@@ -268,15 +268,15 @@ TRACE_EVENT(rcu_quiescent_state_report,
  */
 TRACE_EVENT(rcu_fqs,
 
-        TP_PROTO(char *rcuname, unsigned long gpnum, int cpu, char *qsevent),
+        TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent),
 
         TP_ARGS(rcuname, gpnum, cpu, qsevent),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(unsigned long, gpnum)
                 __field(int, cpu)
-                __field(char *, qsevent)
+                __field(const char *, qsevent)
         ),
 
         TP_fast_assign(
@@ -308,12 +308,12 @@ TRACE_EVENT(rcu_fqs,
  */
 TRACE_EVENT(rcu_dyntick,
 
-        TP_PROTO(char *polarity, long long oldnesting, long long newnesting),
+        TP_PROTO(const char *polarity, long long oldnesting, long long newnesting),
 
         TP_ARGS(polarity, oldnesting, newnesting),
 
         TP_STRUCT__entry(
-                __field(char *, polarity)
+                __field(const char *, polarity)
                 __field(long long, oldnesting)
                 __field(long long, newnesting)
         ),
@@ -352,12 +352,12 @@ TRACE_EVENT(rcu_dyntick,
  */
 TRACE_EVENT(rcu_prep_idle,
 
-        TP_PROTO(char *reason),
+        TP_PROTO(const char *reason),
 
         TP_ARGS(reason),
 
         TP_STRUCT__entry(
-                __field(char *, reason)
+                __field(const char *, reason)
         ),
 
         TP_fast_assign(
@@ -376,13 +376,13 @@ TRACE_EVENT(rcu_prep_idle,
  */
 TRACE_EVENT(rcu_callback,
 
-        TP_PROTO(char *rcuname, struct rcu_head *rhp, long qlen_lazy,
+        TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy,
                  long qlen),
 
         TP_ARGS(rcuname, rhp, qlen_lazy, qlen),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(void *, rhp)
                 __field(void *, func)
                 __field(long, qlen_lazy)
@@ -412,13 +412,13 @@ TRACE_EVENT(rcu_callback,
  */
 TRACE_EVENT(rcu_kfree_callback,
 
-        TP_PROTO(char *rcuname, struct rcu_head *rhp, unsigned long offset,
+        TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset,
                  long qlen_lazy, long qlen),
 
         TP_ARGS(rcuname, rhp, offset, qlen_lazy, qlen),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(void *, rhp)
                 __field(unsigned long, offset)
                 __field(long, qlen_lazy)
@@ -447,12 +447,12 @@ TRACE_EVENT(rcu_kfree_callback,
  */
 TRACE_EVENT(rcu_batch_start,
 
-        TP_PROTO(char *rcuname, long qlen_lazy, long qlen, long blimit),
+        TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit),
 
         TP_ARGS(rcuname, qlen_lazy, qlen, blimit),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(long, qlen_lazy)
                 __field(long, qlen)
                 __field(long, blimit)
@@ -477,12 +477,12 @@ TRACE_EVENT(rcu_batch_start,
  */
 TRACE_EVENT(rcu_invoke_callback,
 
-        TP_PROTO(char *rcuname, struct rcu_head *rhp),
+        TP_PROTO(const char *rcuname, struct rcu_head *rhp),
 
         TP_ARGS(rcuname, rhp),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(void *, rhp)
                 __field(void *, func)
         ),
@@ -506,12 +506,12 @@ TRACE_EVENT(rcu_invoke_callback,
  */
 TRACE_EVENT(rcu_invoke_kfree_callback,
 
-        TP_PROTO(char *rcuname, struct rcu_head *rhp, unsigned long offset),
+        TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset),
 
         TP_ARGS(rcuname, rhp, offset),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(void *, rhp)
                 __field(unsigned long, offset)
         ),
@@ -539,13 +539,13 @@ TRACE_EVENT(rcu_invoke_kfree_callback,
  */
 TRACE_EVENT(rcu_batch_end,
 
-        TP_PROTO(char *rcuname, int callbacks_invoked,
+        TP_PROTO(const char *rcuname, int callbacks_invoked,
                  bool cb, bool nr, bool iit, bool risk),
 
         TP_ARGS(rcuname, callbacks_invoked, cb, nr, iit, risk),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
+                __field(const char *, rcuname)
                 __field(int, callbacks_invoked)
                 __field(bool, cb)
                 __field(bool, nr)
@@ -577,13 +577,13 @@ TRACE_EVENT(rcu_batch_end,
  */
 TRACE_EVENT(rcu_torture_read,
 
-        TP_PROTO(char *rcutorturename, struct rcu_head *rhp,
+        TP_PROTO(const char *rcutorturename, struct rcu_head *rhp,
                  unsigned long secs, unsigned long c_old, unsigned long c),
 
         TP_ARGS(rcutorturename, rhp, secs, c_old, c),
 
         TP_STRUCT__entry(
-                __field(char *, rcutorturename)
+                __field(const char *, rcutorturename)
                 __field(struct rcu_head *, rhp)
                 __field(unsigned long, secs)
                 __field(unsigned long, c_old)
@@ -623,13 +623,13 @@ TRACE_EVENT(rcu_torture_read,
  */
 TRACE_EVENT(rcu_barrier,
 
-        TP_PROTO(char *rcuname, char *s, int cpu, int cnt, unsigned long done),
+        TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done),
 
         TP_ARGS(rcuname, s, cpu, cnt, done),
 
         TP_STRUCT__entry(
-                __field(char *, rcuname)
-                __field(char *, s)
+                __field(const char *, rcuname)
+                __field(const char *, s)
                 __field(int, cpu)
                 __field(int, cnt)
                 __field(unsigned long, done)
diff --git a/include/trace/events/sched.h b/include/trace/events/sched.h
index e5586caff67a..2e7d9947a10d 100644
--- a/include/trace/events/sched.h
+++ b/include/trace/events/sched.h
@@ -57,7 +57,7 @@ DECLARE_EVENT_CLASS(sched_wakeup_template,
 
         TP_PROTO(struct task_struct *p, int success),
 
-        TP_ARGS(p, success),
+        TP_ARGS(__perf_task(p), success),
 
         TP_STRUCT__entry(
                 __array(        char,   comm,   TASK_COMM_LEN   )
@@ -73,9 +73,6 @@ DECLARE_EVENT_CLASS(sched_wakeup_template,
                 __entry->prio           = p->prio;
                 __entry->success        = success;
                 __entry->target_cpu     = task_cpu(p);
-        )
-        TP_perf_assign(
-                __perf_task(p);
         ),
 
         TP_printk("comm=%s pid=%d prio=%d success=%d target_cpu=%03d",
@@ -313,7 +310,7 @@ DECLARE_EVENT_CLASS(sched_stat_template,
 
         TP_PROTO(struct task_struct *tsk, u64 delay),
 
-        TP_ARGS(tsk, delay),
+        TP_ARGS(__perf_task(tsk), __perf_count(delay)),
 
         TP_STRUCT__entry(
                 __array( char,  comm,   TASK_COMM_LEN   )
@@ -325,10 +322,6 @@ DECLARE_EVENT_CLASS(sched_stat_template,
                 memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
                 __entry->pid    = tsk->pid;
                 __entry->delay  = delay;
-        )
-        TP_perf_assign(
-                __perf_count(delay);
-                __perf_task(tsk);
         ),
 
         TP_printk("comm=%s pid=%d delay=%Lu [ns]",
@@ -372,11 +365,11 @@ DEFINE_EVENT(sched_stat_template, sched_stat_blocked,
  * Tracepoint for accounting runtime (time the task is executing
  * on a CPU).
  */
-TRACE_EVENT(sched_stat_runtime,
+DECLARE_EVENT_CLASS(sched_stat_runtime,
 
         TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime),
 
-        TP_ARGS(tsk, runtime, vruntime),
+        TP_ARGS(tsk, __perf_count(runtime), vruntime),
 
         TP_STRUCT__entry(
                 __array( char,  comm,   TASK_COMM_LEN   )
@@ -390,9 +383,6 @@ TRACE_EVENT(sched_stat_runtime,
                 __entry->pid            = tsk->pid;
                 __entry->runtime        = runtime;
                 __entry->vruntime       = vruntime;
-        )
-        TP_perf_assign(
-                __perf_count(runtime);
         ),
 
         TP_printk("comm=%s pid=%d runtime=%Lu [ns] vruntime=%Lu [ns]",
@@ -401,6 +391,10 @@ TRACE_EVENT(sched_stat_runtime,
                         (unsigned long long)__entry->vruntime)
 );
 
+DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime,
+             TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime),
+             TP_ARGS(tsk, runtime, vruntime));
+
 /*
  * Tracepoint for showing priority inheritance modifying a tasks
  * priority.
diff --git a/include/trace/events/sunrpc.h b/include/trace/events/sunrpc.h
index 43be87d5dd58..d51d16c7afd8 100644
--- a/include/trace/events/sunrpc.h
+++ b/include/trace/events/sunrpc.h
@@ -6,6 +6,8 @@
 
 #include <linux/sunrpc/sched.h>
 #include <linux/sunrpc/clnt.h>
+#include <net/tcp_states.h>
+#include <linux/net.h>
 #include <linux/tracepoint.h>
 
 DECLARE_EVENT_CLASS(rpc_task_status,
@@ -15,18 +17,20 @@ DECLARE_EVENT_CLASS(rpc_task_status,
         TP_ARGS(task),
 
         TP_STRUCT__entry(
-                __field(const struct rpc_task *, task)
-                __field(const struct rpc_clnt *, clnt)
+                __field(unsigned int, task_id)
+                __field(unsigned int, client_id)
                 __field(int, status)
         ),
 
         TP_fast_assign(
-                __entry->task = task;
-                __entry->clnt = task->tk_client;
+                __entry->task_id = task->tk_pid;
+                __entry->client_id = task->tk_client->cl_clid;
                 __entry->status = task->tk_status;
         ),
 
-        TP_printk("task:%p@%p, status %d",__entry->task, __entry->clnt, __entry->status)
+        TP_printk("task:%u@%u, status %d",
+                __entry->task_id, __entry->client_id,
+                __entry->status)
 );
 
 DEFINE_EVENT(rpc_task_status, rpc_call_status,
@@ -47,18 +51,20 @@ TRACE_EVENT(rpc_connect_status,
         TP_ARGS(task, status),
 
         TP_STRUCT__entry(
-                __field(const struct rpc_task *, task)
-                __field(const struct rpc_clnt *, clnt)
+                __field(unsigned int, task_id)
+                __field(unsigned int, client_id)
                 __field(int, status)
         ),
 
         TP_fast_assign(
-                __entry->task = task;
-                __entry->clnt = task->tk_client;
+                __entry->task_id = task->tk_pid;
+                __entry->client_id = task->tk_client->cl_clid;
                 __entry->status = status;
         ),
 
-        TP_printk("task:%p@%p, status %d",__entry->task, __entry->clnt, __entry->status)
+        TP_printk("task:%u@%u, status %d",
+                __entry->task_id, __entry->client_id,
+                __entry->status)
 );
 
 DECLARE_EVENT_CLASS(rpc_task_running,
@@ -68,8 +74,8 @@ DECLARE_EVENT_CLASS(rpc_task_running,
         TP_ARGS(clnt, task, action),
 
         TP_STRUCT__entry(
-                __field(const struct rpc_clnt *, clnt)
-                __field(const struct rpc_task *, task)
+                __field(unsigned int, task_id)
+                __field(unsigned int, client_id)
                 __field(const void *, action)
                 __field(unsigned long, runstate)
                 __field(int, status)
@@ -77,17 +83,16 @@ DECLARE_EVENT_CLASS(rpc_task_running,
                 ),
 
         TP_fast_assign(
-                __entry->clnt = clnt;
-                __entry->task = task;
+                __entry->client_id = clnt->cl_clid;
+                __entry->task_id = task->tk_pid;
                 __entry->action = action;
                 __entry->runstate = task->tk_runstate;
                 __entry->status = task->tk_status;
                 __entry->flags = task->tk_flags;
                 ),
 
-        TP_printk("task:%p@%p flags=%4.4x state=%4.4lx status=%d action=%pf",
-                __entry->task,
-                __entry->clnt,
+        TP_printk("task:%u@%u flags=%4.4x state=%4.4lx status=%d action=%pf",
+                __entry->task_id, __entry->client_id,
                 __entry->flags,
                 __entry->runstate,
                 __entry->status,
@@ -126,8 +131,8 @@ DECLARE_EVENT_CLASS(rpc_task_queued,
         TP_ARGS(clnt, task, q),
 
         TP_STRUCT__entry(
-                __field(const struct rpc_clnt *, clnt)
-                __field(const struct rpc_task *, task)
+                __field(unsigned int, task_id)
+                __field(unsigned int, client_id)
                 __field(unsigned long, timeout)
                 __field(unsigned long, runstate)
                 __field(int, status)
@@ -136,8 +141,8 @@ DECLARE_EVENT_CLASS(rpc_task_queued,
                 ),
 
         TP_fast_assign(
-                __entry->clnt = clnt;
-                __entry->task = task;
+                __entry->client_id = clnt->cl_clid;
+                __entry->task_id = task->tk_pid;
                 __entry->timeout = task->tk_timeout;
                 __entry->runstate = task->tk_runstate;
                 __entry->status = task->tk_status;
@@ -145,9 +150,8 @@ DECLARE_EVENT_CLASS(rpc_task_queued,
                 __assign_str(q_name, rpc_qname(q));
                 ),
 
-        TP_printk("task:%p@%p flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s",
-                __entry->task,
-                __entry->clnt,
+        TP_printk("task:%u@%u flags=%4.4x state=%4.4lx status=%d timeout=%lu queue=%s",
+                __entry->task_id, __entry->client_id,
                 __entry->flags,
                 __entry->runstate,
                 __entry->status,
@@ -172,6 +176,135 @@ DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup,
 
 );
 
+#define rpc_show_socket_state(state) \
+        __print_symbolic(state, \
+                { SS_FREE, "FREE" }, \
+                { SS_UNCONNECTED, "UNCONNECTED" }, \
+                { SS_CONNECTING, "CONNECTING," }, \
+                { SS_CONNECTED, "CONNECTED," }, \
+                { SS_DISCONNECTING, "DISCONNECTING" })
+
+#define rpc_show_sock_state(state) \
+        __print_symbolic(state, \
+                { TCP_ESTABLISHED, "ESTABLISHED" }, \
+                { TCP_SYN_SENT, "SYN_SENT" }, \
+                { TCP_SYN_RECV, "SYN_RECV" }, \
+                { TCP_FIN_WAIT1, "FIN_WAIT1" }, \
+                { TCP_FIN_WAIT2, "FIN_WAIT2" }, \
+                { TCP_TIME_WAIT, "TIME_WAIT" }, \
+                { TCP_CLOSE, "CLOSE" }, \
+                { TCP_CLOSE_WAIT, "CLOSE_WAIT" }, \
+                { TCP_LAST_ACK, "LAST_ACK" }, \
+                { TCP_LISTEN, "LISTEN" }, \
+                { TCP_CLOSING, "CLOSING" })
+
+DECLARE_EVENT_CLASS(xs_socket_event,
+
+                TP_PROTO(
+                        struct rpc_xprt *xprt,
+                        struct socket *socket
+                ),
+
+                TP_ARGS(xprt, socket),
+
+                TP_STRUCT__entry(
+                        __field(unsigned int, socket_state)
+                        __field(unsigned int, sock_state)
+                        __field(unsigned long long, ino)
+                        __string(dstaddr,
+                                xprt->address_strings[RPC_DISPLAY_ADDR])
+                        __string(dstport,
+                                xprt->address_strings[RPC_DISPLAY_PORT])
+                ),
+
+                TP_fast_assign(
+                        struct inode *inode = SOCK_INODE(socket);
+                        __entry->socket_state = socket->state;
+                        __entry->sock_state = socket->sk->sk_state;
+                        __entry->ino = (unsigned long long)inode->i_ino;
+                        __assign_str(dstaddr,
+                                xprt->address_strings[RPC_DISPLAY_ADDR]);
+                        __assign_str(dstport,
+                                xprt->address_strings[RPC_DISPLAY_PORT]);
+                ),
+
+                TP_printk(
+                        "socket:[%llu] dstaddr=%s/%s "
+                        "state=%u (%s) sk_state=%u (%s)",
+                        __entry->ino, __get_str(dstaddr), __get_str(dstport),
+                        __entry->socket_state,
+                        rpc_show_socket_state(__entry->socket_state),
+                        __entry->sock_state,
+                        rpc_show_sock_state(__entry->sock_state)
+                )
+);
+#define DEFINE_RPC_SOCKET_EVENT(name) \
+        DEFINE_EVENT(xs_socket_event, name, \
+                        TP_PROTO( \
+                                struct rpc_xprt *xprt, \
+                                struct socket *socket \
+                        ), \
+                        TP_ARGS(xprt, socket))
+
+DECLARE_EVENT_CLASS(xs_socket_event_done,
+
+                TP_PROTO(
+                        struct rpc_xprt *xprt,
+                        struct socket *socket,
+                        int error
+                ),
+
+                TP_ARGS(xprt, socket, error),
+
+                TP_STRUCT__entry(
+                        __field(int, error)
+                        __field(unsigned int, socket_state)
+                        __field(unsigned int, sock_state)
+                        __field(unsigned long long, ino)
+                        __string(dstaddr,
+                                xprt->address_strings[RPC_DISPLAY_ADDR])
+                        __string(dstport,
+                                xprt->address_strings[RPC_DISPLAY_PORT])
+                ),
+
+                TP_fast_assign(
+                        struct inode *inode = SOCK_INODE(socket);
+                        __entry->socket_state = socket->state;
+                        __entry->sock_state = socket->sk->sk_state;
+                        __entry->ino = (unsigned long long)inode->i_ino;
+                        __entry->error = error;
+                        __assign_str(dstaddr,
+                                xprt->address_strings[RPC_DISPLAY_ADDR]);
+                        __assign_str(dstport,
+                                xprt->address_strings[RPC_DISPLAY_PORT]);
+                ),
+
+                TP_printk(
+                        "error=%d socket:[%llu] dstaddr=%s/%s "
+                        "state=%u (%s) sk_state=%u (%s)",
+                        __entry->error,
+                        __entry->ino, __get_str(dstaddr), __get_str(dstport),
+                        __entry->socket_state,
+                        rpc_show_socket_state(__entry->socket_state),
+                        __entry->sock_state,
+                        rpc_show_sock_state(__entry->sock_state)
+                )
+);
+#define DEFINE_RPC_SOCKET_EVENT_DONE(name) \
+        DEFINE_EVENT(xs_socket_event_done, name, \
+                        TP_PROTO( \
+                                struct rpc_xprt *xprt, \
+                                struct socket *socket, \
+                                int error \
+                        ), \
+                        TP_ARGS(xprt, socket, error))
+
+DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change);
+DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect);
+DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection);
+DEFINE_RPC_SOCKET_EVENT(rpc_socket_close);
+DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown);
+
 #endif /* _TRACE_SUNRPC_H */
 
 #include <trace/define_trace.h>
diff --git a/include/trace/events/vmscan.h b/include/trace/events/vmscan.h
index 63cfcccaebb3..132a985aba8b 100644
--- a/include/trace/events/vmscan.h
+++ b/include/trace/events/vmscan.h
@@ -202,7 +202,7 @@ TRACE_EVENT(mm_shrink_slab_start,
 
         TP_fast_assign(
                 __entry->shr = shr;
-                __entry->shrink = shr->shrink;
+                __entry->shrink = shr->scan_objects;
                 __entry->nr_objects_to_shrink = nr_objects_to_shrink;
                 __entry->gfp_flags = sc->gfp_mask;
                 __entry->pgs_scanned = pgs_scanned;
@@ -241,7 +241,7 @@ TRACE_EVENT(mm_shrink_slab_end,
 
         TP_fast_assign(
                 __entry->shr = shr;
-                __entry->shrink = shr->shrink;
+                __entry->shrink = shr->scan_objects;
                 __entry->unused_scan = unused_scan_cnt;
                 __entry->new_scan = new_scan_cnt;
                 __entry->retval = shrinker_retval;
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index 41a6643e2136..5c7ab17cbb02 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -507,8 +507,14 @@ static inline notrace int ftrace_get_offsets_##call(			\
 #undef TP_fast_assign
 #define TP_fast_assign(args...) args
 
-#undef TP_perf_assign
-#define TP_perf_assign(args...)
+#undef __perf_addr
+#define __perf_addr(a)  (a)
+
+#undef __perf_count
+#define __perf_count(c) (c)
+
+#undef __perf_task
+#define __perf_task(t)  (t)
 
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
@@ -636,16 +642,13 @@ __attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
 #define __get_str(field) (char *)__get_dynamic_array(field)
 
 #undef __perf_addr
-#define __perf_addr(a) __addr = (a)
+#define __perf_addr(a)  (__addr = (a))
 
 #undef __perf_count
-#define __perf_count(c) __count = (c)
+#define __perf_count(c) (__count = (c))
 
 #undef __perf_task
-#define __perf_task(t) __task = (t)
-
-#undef TP_perf_assign
-#define TP_perf_assign(args...) args
+#define __perf_task(t)  (__task = (t))
 
 #undef DECLARE_EVENT_CLASS
 #define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)  \
@@ -663,15 +666,20 @@ perf_trace_##call(void *__data, proto)					\
         int __data_size;                                                \
         int rctx;                                                       \
                                                                         \
-        perf_fetch_caller_regs(&__regs);                                \
-                                                                        \
         __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
+                                                                        \
+        head = this_cpu_ptr(event_call->perf_events);                   \
+        if (__builtin_constant_p(!__task) && !__task &&                 \
+                                hlist_empty(head))                      \
+                return;                                                 \
+                                                                        \
         __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\
                              sizeof(u64));                              \
         __entry_size -= sizeof(u32);                                    \
                                                                         \
-        entry = (struct ftrace_raw_##call *)perf_trace_buf_prepare(     \
-                __entry_size, event_call->event.type, &__regs, &rctx);  \
+        perf_fetch_caller_regs(&__regs);                                \
+        entry = perf_trace_buf_prepare(__entry_size,                    \
+                        event_call->event.type, &__regs, &rctx);        \
         if (!entry)                                                     \
                 return;                                                 \
                                                                         \
@@ -679,7 +687,6 @@ perf_trace_##call(void *__data, proto)					\
                                                                         \
         { assign; }                                                     \
                                                                         \
-        head = this_cpu_ptr(event_call->perf_events);                   \
         perf_trace_buf_submit(entry, __entry_size, rctx, __addr,        \
                 __count, &__regs, head, __task);                        \
 }