Merge tag 'staging-3.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging

Pull staging driver updates from Greg KH:
 "Here's the big staging tree pull request for 3.19-rc1.

  We continued to delete more lines than were added, always a good
  thing, but not at a huge rate this release, only about 70k lines
  removed overall mostly from removing the horrid bcm driver.

  Lots of normal staging driver cleanups and fixes all over the place,
  well over a thousand of them, the shortlog shows all the horrid
  details.

  The "contentious" thing here is the movement of the Android binder
  code out of staging into the "real" part of the kernel.  This is code
  that has been stable for a few years now and is working as-is in the
  tens of millions of devices with no issues.  Yes, the code is horrid,
  and the userspace api leaves a lot to be desired, but it's not going
  to change due to legacy issues that we have no control over.  Because
  so many devices and companies rely on this, and the code is stable,
  might as well promote it out of staging.

  This was all discussed at the Linux Plumbers conference, and everyone
  participating agreed that this was the best way forward.

  There is work happening to replace the binder code with something new
  that is happening right now, but I don't expect to see the results of
  that work for another year at the earliest.  If that ever happens, and
  Android switches over to it, I'll gladly remove this version.

  As for maintainers, I'll be glad to maintain this code, I've been
  doing it for the past few years with no problems.  I'll send a
  MAINTAINERS entry for it before 3.19-final is out, still need to talk
  to the Google developers about if they are willing to help with it or
  not, last I checked they were, which was good.

  All of these patches have been in linux-next for a while with no
  reported issues"

* tag 'staging-3.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging: (1382 commits)
  Staging: slicoss: Fix long line issues in slicoss.c
  staging: rtl8712: remove unnecessary else after return
  staging: comedi: change some printk calls to pr_err
  staging: rtl8723au: hal: Removed the extra semicolon
  lustre: Deletion of unnecessary checks before three function calls
  staging: lustre: fix sparse warnings: static function declaration
  staging: lustre: fixed sparse warnings related to static declarations
  staging: unisys: remove duplicate header
  staging: unisys: remove unneeded structure
  staging: ft1000 : replace __attribute ((__packed__) with __packed
  drivers: staging: rtl8192e: Include "asm/unaligned.h" instead of "access_ok.h" in "rtl819x_BAProc.c"
  Drivers:staging:rtl8192e: Fixed checkpatch warning
  Drivers:staging:clocking-wizard: Added a newline
  staging: clocking-wizard: check for a valid clk_name pointer
  staging: rtl8723au: Hal_InitPGData() avoid unnecessary typecasts
  staging: rtl8723au: _DisableAnalog(): Avoid zero-init variables unnecessarily
  staging: rtl8723au: Remove unnecessary wrapper _ResetDigitalProcedure1()
  staging: rtl8723au: _ResetDigitalProcedure1_92C() reduce code obfuscation
  staging: rtl8723au: Remove unnecessary wrapper _DisableRFAFEAndResetBB()
  staging: rtl8723au: _DisableRFAFEAndResetBB8192C(): Reduce code obfuscation
  ...

1 files changed, 329 insertions, 0 deletions

diff --git a/drivers/android/binder_trace.h b/drivers/android/binder_trace.h
new file mode 100644
index 000000000000..7f20f3dc8369
--- /dev/null
+++ b/drivers/android/binder_trace.h
@@ -0,0 +1,329 @@
+/*
+ * Copyright (C) 2012 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM binder
+
+#if !defined(_BINDER_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _BINDER_TRACE_H
+
+#include <linux/tracepoint.h>
+
+struct binder_buffer;
+struct binder_node;
+struct binder_proc;
+struct binder_ref;
+struct binder_thread;
+struct binder_transaction;
+
+TRACE_EVENT(binder_ioctl,
+        TP_PROTO(unsigned int cmd, unsigned long arg),
+        TP_ARGS(cmd, arg),
+
+        TP_STRUCT__entry(
+                __field(unsigned int, cmd)
+                __field(unsigned long, arg)
+        ),
+        TP_fast_assign(
+                __entry->cmd = cmd;
+                __entry->arg = arg;
+        ),
+        TP_printk("cmd=0x%x arg=0x%lx", __entry->cmd, __entry->arg)
+);
+
+DECLARE_EVENT_CLASS(binder_lock_class,
+        TP_PROTO(const char *tag),
+        TP_ARGS(tag),
+        TP_STRUCT__entry(
+                __field(const char *, tag)
+        ),
+        TP_fast_assign(
+                __entry->tag = tag;
+        ),
+        TP_printk("tag=%s", __entry->tag)
+);
+
+#define DEFINE_BINDER_LOCK_EVENT(name)  \
+DEFINE_EVENT(binder_lock_class, name,   \
+        TP_PROTO(const char *func), \
+        TP_ARGS(func))
+
+DEFINE_BINDER_LOCK_EVENT(binder_lock);
+DEFINE_BINDER_LOCK_EVENT(binder_locked);
+DEFINE_BINDER_LOCK_EVENT(binder_unlock);
+
+DECLARE_EVENT_CLASS(binder_function_return_class,
+        TP_PROTO(int ret),
+        TP_ARGS(ret),
+        TP_STRUCT__entry(
+                __field(int, ret)
+        ),
+        TP_fast_assign(
+                __entry->ret = ret;
+        ),
+        TP_printk("ret=%d", __entry->ret)
+);
+
+#define DEFINE_BINDER_FUNCTION_RETURN_EVENT(name)       \
+DEFINE_EVENT(binder_function_return_class, name,        \
+        TP_PROTO(int ret), \
+        TP_ARGS(ret))
+
+DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_ioctl_done);
+DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_write_done);
+DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_read_done);
+
+TRACE_EVENT(binder_wait_for_work,
+        TP_PROTO(bool proc_work, bool transaction_stack, bool thread_todo),
+        TP_ARGS(proc_work, transaction_stack, thread_todo),
+
+        TP_STRUCT__entry(
+                __field(bool, proc_work)
+                __field(bool, transaction_stack)
+                __field(bool, thread_todo)
+        ),
+        TP_fast_assign(
+                __entry->proc_work = proc_work;
+                __entry->transaction_stack = transaction_stack;
+                __entry->thread_todo = thread_todo;
+        ),
+        TP_printk("proc_work=%d transaction_stack=%d thread_todo=%d",
+                  __entry->proc_work, __entry->transaction_stack,
+                  __entry->thread_todo)
+);
+
+TRACE_EVENT(binder_transaction,
+        TP_PROTO(bool reply, struct binder_transaction *t,
+                 struct binder_node *target_node),
+        TP_ARGS(reply, t, target_node),
+        TP_STRUCT__entry(
+                __field(int, debug_id)
+                __field(int, target_node)
+                __field(int, to_proc)
+                __field(int, to_thread)
+                __field(int, reply)
+                __field(unsigned int, code)
+                __field(unsigned int, flags)
+        ),
+        TP_fast_assign(
+                __entry->debug_id = t->debug_id;
+                __entry->target_node = target_node ? target_node->debug_id : 0;
+                __entry->to_proc = t->to_proc->pid;
+                __entry->to_thread = t->to_thread ? t->to_thread->pid : 0;
+                __entry->reply = reply;
+                __entry->code = t->code;
+                __entry->flags = t->flags;
+        ),
+        TP_printk("transaction=%d dest_node=%d dest_proc=%d dest_thread=%d reply=%d flags=0x%x code=0x%x",
+                  __entry->debug_id, __entry->target_node,
+                  __entry->to_proc, __entry->to_thread,
+                  __entry->reply, __entry->flags, __entry->code)
+);
+
+TRACE_EVENT(binder_transaction_received,
+        TP_PROTO(struct binder_transaction *t),
+        TP_ARGS(t),
+
+        TP_STRUCT__entry(
+                __field(int, debug_id)
+        ),
+        TP_fast_assign(
+                __entry->debug_id = t->debug_id;
+        ),
+        TP_printk("transaction=%d", __entry->debug_id)
+);
+
+TRACE_EVENT(binder_transaction_node_to_ref,
+        TP_PROTO(struct binder_transaction *t, struct binder_node *node,
+                 struct binder_ref *ref),
+        TP_ARGS(t, node, ref),
+
+        TP_STRUCT__entry(
+                __field(int, debug_id)
+                __field(int, node_debug_id)
+                __field(binder_uintptr_t, node_ptr)
+                __field(int, ref_debug_id)
+                __field(uint32_t, ref_desc)
+        ),
+        TP_fast_assign(
+                __entry->debug_id = t->debug_id;
+                __entry->node_debug_id = node->debug_id;
+                __entry->node_ptr = node->ptr;
+                __entry->ref_debug_id = ref->debug_id;
+                __entry->ref_desc = ref->desc;
+        ),
+        TP_printk("transaction=%d node=%d src_ptr=0x%016llx ==> dest_ref=%d dest_desc=%d",
+                  __entry->debug_id, __entry->node_debug_id,
+                  (u64)__entry->node_ptr,
+                  __entry->ref_debug_id, __entry->ref_desc)
+);
+
+TRACE_EVENT(binder_transaction_ref_to_node,
+        TP_PROTO(struct binder_transaction *t, struct binder_ref *ref),
+        TP_ARGS(t, ref),
+
+        TP_STRUCT__entry(
+                __field(int, debug_id)
+                __field(int, ref_debug_id)
+                __field(uint32_t, ref_desc)
+                __field(int, node_debug_id)
+                __field(binder_uintptr_t, node_ptr)
+        ),
+        TP_fast_assign(
+                __entry->debug_id = t->debug_id;
+                __entry->ref_debug_id = ref->debug_id;
+                __entry->ref_desc = ref->desc;
+                __entry->node_debug_id = ref->node->debug_id;
+                __entry->node_ptr = ref->node->ptr;
+        ),
+        TP_printk("transaction=%d node=%d src_ref=%d src_desc=%d ==> dest_ptr=0x%016llx",
+                  __entry->debug_id, __entry->node_debug_id,
+                  __entry->ref_debug_id, __entry->ref_desc,
+                  (u64)__entry->node_ptr)
+);
+
+TRACE_EVENT(binder_transaction_ref_to_ref,
+        TP_PROTO(struct binder_transaction *t, struct binder_ref *src_ref,
+                 struct binder_ref *dest_ref),
+        TP_ARGS(t, src_ref, dest_ref),
+
+        TP_STRUCT__entry(
+                __field(int, debug_id)
+                __field(int, node_debug_id)
+                __field(int, src_ref_debug_id)
+                __field(uint32_t, src_ref_desc)
+                __field(int, dest_ref_debug_id)
+                __field(uint32_t, dest_ref_desc)
+        ),
+        TP_fast_assign(
+                __entry->debug_id = t->debug_id;
+                __entry->node_debug_id = src_ref->node->debug_id;
+                __entry->src_ref_debug_id = src_ref->debug_id;
+                __entry->src_ref_desc = src_ref->desc;
+                __entry->dest_ref_debug_id = dest_ref->debug_id;
+                __entry->dest_ref_desc = dest_ref->desc;
+        ),
+        TP_printk("transaction=%d node=%d src_ref=%d src_desc=%d ==> dest_ref=%d dest_desc=%d",
+                  __entry->debug_id, __entry->node_debug_id,
+                  __entry->src_ref_debug_id, __entry->src_ref_desc,
+                  __entry->dest_ref_debug_id, __entry->dest_ref_desc)
+);
+
+TRACE_EVENT(binder_transaction_fd,
+        TP_PROTO(struct binder_transaction *t, int src_fd, int dest_fd),
+        TP_ARGS(t, src_fd, dest_fd),
+
+        TP_STRUCT__entry(
+                __field(int, debug_id)
+                __field(int, src_fd)
+                __field(int, dest_fd)
+        ),
+        TP_fast_assign(
+                __entry->debug_id = t->debug_id;
+                __entry->src_fd = src_fd;
+                __entry->dest_fd = dest_fd;
+        ),
+        TP_printk("transaction=%d src_fd=%d ==> dest_fd=%d",
+                  __entry->debug_id, __entry->src_fd, __entry->dest_fd)
+);
+
+DECLARE_EVENT_CLASS(binder_buffer_class,
+        TP_PROTO(struct binder_buffer *buf),
+        TP_ARGS(buf),
+        TP_STRUCT__entry(
+                __field(int, debug_id)
+                __field(size_t, data_size)
+                __field(size_t, offsets_size)
+        ),
+        TP_fast_assign(
+                __entry->debug_id = buf->debug_id;
+                __entry->data_size = buf->data_size;
+                __entry->offsets_size = buf->offsets_size;
+        ),
+        TP_printk("transaction=%d data_size=%zd offsets_size=%zd",
+                  __entry->debug_id, __entry->data_size, __entry->offsets_size)
+);
+
+DEFINE_EVENT(binder_buffer_class, binder_transaction_alloc_buf,
+        TP_PROTO(struct binder_buffer *buffer),
+        TP_ARGS(buffer));
+
+DEFINE_EVENT(binder_buffer_class, binder_transaction_buffer_release,
+        TP_PROTO(struct binder_buffer *buffer),
+        TP_ARGS(buffer));
+
+DEFINE_EVENT(binder_buffer_class, binder_transaction_failed_buffer_release,
+        TP_PROTO(struct binder_buffer *buffer),
+        TP_ARGS(buffer));
+
+TRACE_EVENT(binder_update_page_range,
+        TP_PROTO(struct binder_proc *proc, bool allocate,
+                 void *start, void *end),
+        TP_ARGS(proc, allocate, start, end),
+        TP_STRUCT__entry(
+                __field(int, proc)
+                __field(bool, allocate)
+                __field(size_t, offset)
+                __field(size_t, size)
+        ),
+        TP_fast_assign(
+                __entry->proc = proc->pid;
+                __entry->allocate = allocate;
+                __entry->offset = start - proc->buffer;
+                __entry->size = end - start;
+        ),
+        TP_printk("proc=%d allocate=%d offset=%zu size=%zu",
+                  __entry->proc, __entry->allocate,
+                  __entry->offset, __entry->size)
+);
+
+TRACE_EVENT(binder_command,
+        TP_PROTO(uint32_t cmd),
+        TP_ARGS(cmd),
+        TP_STRUCT__entry(
+                __field(uint32_t, cmd)
+        ),
+        TP_fast_assign(
+                __entry->cmd = cmd;
+        ),
+        TP_printk("cmd=0x%x %s",
+                  __entry->cmd,
+                  _IOC_NR(__entry->cmd) < ARRAY_SIZE(binder_command_strings) ?
+                          binder_command_strings[_IOC_NR(__entry->cmd)] :
+                          "unknown")
+);
+
+TRACE_EVENT(binder_return,
+        TP_PROTO(uint32_t cmd),
+        TP_ARGS(cmd),
+        TP_STRUCT__entry(
+                __field(uint32_t, cmd)
+        ),
+        TP_fast_assign(
+                __entry->cmd = cmd;
+        ),
+        TP_printk("cmd=0x%x %s",
+                  __entry->cmd,
+                  _IOC_NR(__entry->cmd) < ARRAY_SIZE(binder_return_strings) ?
+                          binder_return_strings[_IOC_NR(__entry->cmd)] :
+                          "unknown")
+);
+
+#endif /* _BINDER_TRACE_H */
+
+#undef TRACE_INCLUDE_PATH
+#undef TRACE_INCLUDE_FILE
+#define TRACE_INCLUDE_PATH .
+#define TRACE_INCLUDE_FILE binder_trace
+#include <trace/define_trace.h>