7 files changed, 224 insertions, 48 deletions

diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index d7cd193c2277..a81170de7f6b 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -89,7 +89,9 @@ enum print_line_t {
         TRACE_TYPE_NO_CONSUME   = 3     /* Handled but ask to not consume */
 };
 
-
+void tracing_generic_entry_update(struct trace_entry *entry,
+                                  unsigned long flags,
+                                  int pc);
 struct ring_buffer_event *
 trace_current_buffer_lock_reserve(int type, unsigned long len,
                                   unsigned long flags, int pc);
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 16713dc672e4..3060bdc35ffe 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -110,6 +110,7 @@ struct kvm_memory_slot {
 
 struct kvm_kernel_irq_routing_entry {
         u32 gsi;
+        u32 type;
         int (*set)(struct kvm_kernel_irq_routing_entry *e,
                     struct kvm *kvm, int level);
         union {
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index fdffb413b192..f6b90240dd41 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -473,7 +473,6 @@ extern int  nfs_writepages(struct address_space *, struct writeback_control *);
 extern int  nfs_flush_incompatible(struct file *file, struct page *page);
 extern int  nfs_updatepage(struct file *, struct page *, unsigned int, unsigned int);
 extern int nfs_writeback_done(struct rpc_task *, struct nfs_write_data *);
-extern void nfs_writedata_release(void *);
 
 /*
  * Try to write back everything synchronously (but check the
@@ -488,7 +487,6 @@ extern int nfs_wb_page_cancel(struct inode *inode, struct page* page);
 extern int  nfs_commit_inode(struct inode *, int);
 extern struct nfs_write_data *nfs_commitdata_alloc(void);
 extern void nfs_commit_free(struct nfs_write_data *wdata);
-extern void nfs_commitdata_release(void *wdata);
 #else
 static inline int
 nfs_commit_inode(struct inode *inode, int how)
@@ -507,6 +505,7 @@ nfs_have_writebacks(struct inode *inode)
  * Allocate nfs_write_data structures
  */
 extern struct nfs_write_data *nfs_writedata_alloc(unsigned int npages);
+extern void nfs_writedata_free(struct nfs_write_data *);
 
 /*
  * linux/fs/nfs/read.c
@@ -515,7 +514,6 @@ extern int  nfs_readpage(struct file *, struct page *);
 extern int  nfs_readpages(struct file *, struct address_space *,
                 struct list_head *, unsigned);
 extern int  nfs_readpage_result(struct rpc_task *, struct nfs_read_data *);
-extern void nfs_readdata_release(void *data);
 extern int  nfs_readpage_async(struct nfs_open_context *, struct inode *,
                                struct page *);
 
@@ -523,6 +521,7 @@ extern int  nfs_readpage_async(struct nfs_open_context *, struct inode *,
  * Allocate nfs_read_data structures
  */
 extern struct nfs_read_data *nfs_readdata_alloc(unsigned int npages);
+extern void nfs_readdata_free(struct nfs_read_data *);
 
 /*
  * linux/fs/nfs3proc.c
diff --git a/include/linux/perf_counter.h b/include/linux/perf_counter.h
index e604e6ef72dd..b53f7006cc4e 100644
--- a/include/linux/perf_counter.h
+++ b/include/linux/perf_counter.h
@@ -115,27 +115,44 @@ enum perf_counter_sample_format {
         PERF_SAMPLE_TID                         = 1U << 1,
         PERF_SAMPLE_TIME                        = 1U << 2,
         PERF_SAMPLE_ADDR                        = 1U << 3,
-        PERF_SAMPLE_GROUP                       = 1U << 4,
+        PERF_SAMPLE_READ                        = 1U << 4,
         PERF_SAMPLE_CALLCHAIN                   = 1U << 5,
         PERF_SAMPLE_ID                          = 1U << 6,
         PERF_SAMPLE_CPU                         = 1U << 7,
         PERF_SAMPLE_PERIOD                      = 1U << 8,
         PERF_SAMPLE_STREAM_ID                   = 1U << 9,
+        PERF_SAMPLE_RAW                         = 1U << 10,
 
-        PERF_SAMPLE_MAX = 1U << 10,             /* non-ABI */
+        PERF_SAMPLE_MAX = 1U << 11,             /* non-ABI */
 };
 
 /*
- * Bits that can be set in attr.read_format to request that
- * reads on the counter should return the indicated quantities,
- * in increasing order of bit value, after the counter value.
+ * The format of the data returned by read() on a perf counter fd,
+ * as specified by attr.read_format:
+ *
+ * struct read_format {
+ *      { u64           value;
+ *        { u64         time_enabled; } && PERF_FORMAT_ENABLED
+ *        { u64         time_running; } && PERF_FORMAT_RUNNING
+ *        { u64         id;           } && PERF_FORMAT_ID
+ *      } && !PERF_FORMAT_GROUP
+ *
+ *      { u64           nr;
+ *        { u64         time_enabled; } && PERF_FORMAT_ENABLED
+ *        { u64         time_running; } && PERF_FORMAT_RUNNING
+ *        { u64         value;
+ *          { u64       id;           } && PERF_FORMAT_ID
+ *        }             cntr[nr];
+ *      } && PERF_FORMAT_GROUP
+ * };
  */
 enum perf_counter_read_format {
         PERF_FORMAT_TOTAL_TIME_ENABLED          = 1U << 0,
         PERF_FORMAT_TOTAL_TIME_RUNNING          = 1U << 1,
         PERF_FORMAT_ID                          = 1U << 2,
+        PERF_FORMAT_GROUP                       = 1U << 3,
 
-        PERF_FORMAT_MAX = 1U << 3,              /* non-ABI */
+        PERF_FORMAT_MAX = 1U << 4,              /* non-ABI */
 };
 
 #define PERF_ATTR_SIZE_VER0     64      /* sizeof first published struct */
@@ -342,10 +359,8 @@ enum perf_event_type {
          * struct {
          *      struct perf_event_header        header;
          *      u32                             pid, tid;
-         *      u64                             value;
-         *      { u64           time_enabled;   } && PERF_FORMAT_ENABLED
-         *      { u64           time_running;   } && PERF_FORMAT_RUNNING
-         *      { u64           parent_id;      } && PERF_FORMAT_ID
+         *
+         *      struct read_format              values;
          * };
          */
         PERF_EVENT_READ                 = 8,
@@ -363,11 +378,24 @@ enum perf_event_type {
          *      { u32                   cpu, res; } && PERF_SAMPLE_CPU
          *      { u64                   period;   } && PERF_SAMPLE_PERIOD
          *
-         *      { u64                   nr;
-         *        { u64 id, val; }      cnt[nr];  } && PERF_SAMPLE_GROUP
+         *      { struct read_format    values;   } && PERF_SAMPLE_READ
          *
          *      { u64                   nr,
          *        u64                   ips[nr];  } && PERF_SAMPLE_CALLCHAIN
+         *
+         *      #
+         *      # The RAW record below is opaque data wrt the ABI
+         *      #
+         *      # That is, the ABI doesn't make any promises wrt to
+         *      # the stability of its content, it may vary depending
+         *      # on event, hardware, kernel version and phase of
+         *      # the moon.
+         *      #
+         *      # In other words, PERF_SAMPLE_RAW contents are not an ABI.
+         *      #
+         *
+         *      { u32                   size;
+         *        char                  data[size];}&& PERF_SAMPLE_RAW
          * };
          */
         PERF_EVENT_SAMPLE               = 9,
@@ -413,6 +441,11 @@ struct perf_callchain_entry {
         __u64                           ip[PERF_MAX_STACK_DEPTH];
 };
 
+struct perf_raw_record {
+        u32                             size;
+        void                            *data;
+};
+
 struct task_struct;
 
 /**
@@ -681,10 +714,13 @@ struct perf_sample_data {
         struct pt_regs                  *regs;
         u64                             addr;
         u64                             period;
+        struct perf_raw_record          *raw;
 };
 
 extern int perf_counter_overflow(struct perf_counter *counter, int nmi,
                                  struct perf_sample_data *data);
+extern void perf_counter_output(struct perf_counter *counter, int nmi,
+                                struct perf_sample_data *data);
 
 /*
  * Return 1 for a software counter, 0 for a hardware counter
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index b99c625fddfe..7da466ba4b0d 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -117,17 +117,15 @@ static inline __be32 *xdr_encode_array(__be32 *p, const void *s, unsigned int le
 static inline __be32 *
 xdr_encode_hyper(__be32 *p, __u64 val)
 {
-        *p++ = htonl(val >> 32);
-        *p++ = htonl(val & 0xFFFFFFFF);
-        return p;
+        *(__be64 *)p = cpu_to_be64(val);
+        return p + 2;
 }
 
 static inline __be32 *
 xdr_decode_hyper(__be32 *p, __u64 *valp)
 {
-        *valp  = ((__u64) ntohl(*p++)) << 32;
-        *valp |= ntohl(*p++);
-        return p;
+        *valp = be64_to_cpup((__be64 *)p);
+        return p + 2;
 }
 
 /*
diff --git a/include/linux/wait.h b/include/linux/wait.h
index 6788e1a4d4ca..cf3c2f5dba51 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -77,7 +77,14 @@ struct task_struct;
 #define __WAIT_BIT_KEY_INITIALIZER(word, bit)                           \
         { .flags = word, .bit_nr = bit, }
 
-extern void init_waitqueue_head(wait_queue_head_t *q);
+extern void __init_waitqueue_head(wait_queue_head_t *q, struct lock_class_key *);
+
+#define init_waitqueue_head(q)                          \
+        do {                                            \
+                static struct lock_class_key __key;     \
+                                                        \
+                __init_waitqueue_head((q), &__key);     \
+        } while (0)
 
 #ifdef CONFIG_LOCKDEP
 # define __WAIT_QUEUE_HEAD_INIT_ONSTACK(name) \
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index 1867553c61e5..f64fbaae781a 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -144,6 +144,9 @@
 #undef TP_fast_assign
 #define TP_fast_assign(args...) args
 
+#undef TP_perf_assign
+#define TP_perf_assign(args...)
+
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, func, print)            \
 static int                                                              \
@@ -345,6 +348,56 @@ static inline int ftrace_get_offsets_##call(				\
 
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
+#ifdef CONFIG_EVENT_PROFILE
+
+/*
+ * Generate the functions needed for tracepoint perf_counter support.
+ *
+ * NOTE: The insertion profile callback (ftrace_profile_<call>) is defined later
+ *
+ * static int ftrace_profile_enable_<call>(struct ftrace_event_call *event_call)
+ * {
+ *      int ret = 0;
+ *
+ *      if (!atomic_inc_return(&event_call->profile_count))
+ *              ret = register_trace_<call>(ftrace_profile_<call>);
+ *
+ *      return ret;
+ * }
+ *
+ * static void ftrace_profile_disable_<call>(struct ftrace_event_call *event_call)
+ * {
+ *      if (atomic_add_negative(-1, &event->call->profile_count))
+ *              unregister_trace_<call>(ftrace_profile_<call>);
+ * }
+ *
+ */
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(call, proto, args, tstruct, assign, print)          \
+                                                                        \
+static void ftrace_profile_##call(proto);                               \
+                                                                        \
+static int ftrace_profile_enable_##call(struct ftrace_event_call *event_call) \
+{                                                                       \
+        int ret = 0;                                                    \
+                                                                        \
+        if (!atomic_inc_return(&event_call->profile_count))             \
+                ret = register_trace_##call(ftrace_profile_##call);     \
+                                                                        \
+        return ret;                                                     \
+}                                                                       \
+                                                                        \
+static void ftrace_profile_disable_##call(struct ftrace_event_call *event_call)\
+{                                                                       \
+        if (atomic_add_negative(-1, &event_call->profile_count))        \
+                unregister_trace_##call(ftrace_profile_##call);         \
+}
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+#endif
+
 /*
  * Stage 4 of the trace events.
  *
@@ -447,28 +500,6 @@ static inline int ftrace_get_offsets_##call(				\
 #define TP_FMT(fmt, args...)    fmt "\n", ##args
 
 #ifdef CONFIG_EVENT_PROFILE
-#define _TRACE_PROFILE(call, proto, args)                               \
-static void ftrace_profile_##call(proto)                                \
-{                                                                       \
-        extern void perf_tpcounter_event(int);                          \
-        perf_tpcounter_event(event_##call.id);                          \
-}                                                                       \
-                                                                        \
-static int ftrace_profile_enable_##call(struct ftrace_event_call *event_call) \
-{                                                                       \
-        int ret = 0;                                                    \
-                                                                        \
-        if (!atomic_inc_return(&event_call->profile_count))             \
-                ret = register_trace_##call(ftrace_profile_##call);     \
-                                                                        \
-        return ret;                                                     \
-}                                                                       \
-                                                                        \
-static void ftrace_profile_disable_##call(struct ftrace_event_call *event_call)\
-{                                                                       \
-        if (atomic_add_negative(-1, &event_call->profile_count))        \
-                unregister_trace_##call(ftrace_profile_##call);         \
-}
 
 #define _TRACE_PROFILE_INIT(call)                                       \
         .profile_count = ATOMIC_INIT(-1),                               \
@@ -476,7 +507,6 @@ static void ftrace_profile_disable_##call(struct ftrace_event_call *event_call)\
         .profile_disable = ftrace_profile_disable_##call,
 
 #else
-#define _TRACE_PROFILE(call, proto, args)
 #define _TRACE_PROFILE_INIT(call)
 #endif
 
@@ -502,7 +532,6 @@ static void ftrace_profile_disable_##call(struct ftrace_event_call *event_call)\
 
 #undef TRACE_EVENT
 #define TRACE_EVENT(call, proto, args, tstruct, assign, print)          \
-_TRACE_PROFILE(call, PARAMS(proto), PARAMS(args))                       \
                                                                         \
 static struct ftrace_event_call event_##call;                           \
                                                                         \
@@ -586,6 +615,110 @@ __attribute__((section("_ftrace_events"))) event_##call = {		\
 
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
-#undef _TRACE_PROFILE
+/*
+ * Define the insertion callback to profile events
+ *
+ * The job is very similar to ftrace_raw_event_<call> except that we don't
+ * insert in the ring buffer but in a perf counter.
+ *
+ * static void ftrace_profile_<call>(proto)
+ * {
+ *      struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
+ *      struct ftrace_event_call *event_call = &event_<call>;
+ *      extern void perf_tpcounter_event(int, u64, u64, void *, int);
+ *      struct ftrace_raw_##call *entry;
+ *      u64 __addr = 0, __count = 1;
+ *      unsigned long irq_flags;
+ *      int __entry_size;
+ *      int __data_size;
+ *      int pc;
+ *
+ *      local_save_flags(irq_flags);
+ *      pc = preempt_count();
+ *
+ *      __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
+ *
+ *      // Below we want to get the aligned size by taking into account
+ *      // the u32 field that will later store the buffer size
+ *      __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),
+ *                           sizeof(u64));
+ *      __entry_size -= sizeof(u32);
+ *
+ *      do {
+ *              char raw_data[__entry_size]; <- allocate our sample in the stack
+ *              struct trace_entry *ent;
+ *
+ *              zero dead bytes from alignment to avoid stack leak to userspace:
+ *
+ *              *(u64 *)(&raw_data[__entry_size - sizeof(u64)]) = 0ULL;
+ *              entry = (struct ftrace_raw_<call> *)raw_data;
+ *              ent = &entry->ent;
+ *              tracing_generic_entry_update(ent, irq_flags, pc);
+ *              ent->type = event_call->id;
+ *
+ *              <tstruct> <- do some jobs with dynamic arrays
+ *
+ *              <assign>  <- affect our values
+ *
+ *              perf_tpcounter_event(event_call->id, __addr, __count, entry,
+ *                           __entry_size);  <- submit them to perf counter
+ *      } while (0);
+ *
+ * }
+ */
+
+#ifdef CONFIG_EVENT_PROFILE
+
+#undef __perf_addr
+#define __perf_addr(a) __addr = (a)
+
+#undef __perf_count
+#define __perf_count(c) __count = (c)
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(call, proto, args, tstruct, assign, print)          \
+static void ftrace_profile_##call(proto)                                \
+{                                                                       \
+        struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
+        struct ftrace_event_call *event_call = &event_##call;           \
+        extern void perf_tpcounter_event(int, u64, u64, void *, int);   \
+        struct ftrace_raw_##call *entry;                                \
+        u64 __addr = 0, __count = 1;                                    \
+        unsigned long irq_flags;                                        \
+        int __entry_size;                                               \
+        int __data_size;                                                \
+        int pc;                                                         \
+                                                                        \
+        local_save_flags(irq_flags);                                    \
+        pc = preempt_count();                                           \
+                                                                        \
+        __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
+        __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),\
+                             sizeof(u64));                              \
+        __entry_size -= sizeof(u32);                                    \
+                                                                        \
+        do {                                                            \
+                char raw_data[__entry_size];                            \
+                struct trace_entry *ent;                                \
+                                                                        \
+                *(u64 *)(&raw_data[__entry_size - sizeof(u64)]) = 0ULL; \
+                entry = (struct ftrace_raw_##call *)raw_data;           \
+                ent = &entry->ent;                                      \
+                tracing_generic_entry_update(ent, irq_flags, pc);       \
+                ent->type = event_call->id;                             \
+                                                                        \
+                tstruct                                                 \
+                                                                        \
+                { assign; }                                             \
+                                                                        \
+                perf_tpcounter_event(event_call->id, __addr, __count, entry,\
+                             __entry_size);                             \
+        } while (0);                                                    \
+                                                                        \
+}
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+#endif /* CONFIG_EVENT_PROFILE */
+
 #undef _TRACE_PROFILE_INIT