[linux-2.6-block.git] / drivers / android / binder_trace.h

/*
 * 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_alloc;
struct binder_ref_data;
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_data *rdata),
	TP_ARGS(t, node, rdata),

	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 = rdata->debug_id;
		__entry->ref_desc = rdata->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_node *node,
		 struct binder_ref_data *rdata),
	TP_ARGS(t, node, rdata),

	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 = rdata->debug_id;
		__entry->ref_desc = rdata->desc;
		__entry->node_debug_id = node->debug_id;
		__entry->node_ptr = 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_node *node,
		 struct binder_ref_data *src_ref,
		 struct binder_ref_data *dest_ref),
	TP_ARGS(t, node, 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 = 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_send,
	TP_PROTO(struct binder_transaction *t, int fd, size_t offset),
	TP_ARGS(t, fd, offset),

	TP_STRUCT__entry(
		__field(int, debug_id)
		__field(int, fd)
		__field(size_t, offset)
	),
	TP_fast_assign(
		__entry->debug_id = t->debug_id;
		__entry->fd = fd;
		__entry->offset = offset;
	),
	TP_printk("transaction=%d src_fd=%d offset=%zu",
		  __entry->debug_id, __entry->fd, __entry->offset)
);

TRACE_EVENT(binder_transaction_fd_recv,
	TP_PROTO(struct binder_transaction *t, int fd, size_t offset),
	TP_ARGS(t, fd, offset),

	TP_STRUCT__entry(
		__field(int, debug_id)
		__field(int, fd)
		__field(size_t, offset)
	),
	TP_fast_assign(
		__entry->debug_id = t->debug_id;
		__entry->fd = fd;
		__entry->offset = offset;
	),
	TP_printk("transaction=%d dest_fd=%d offset=%zu",
		  __entry->debug_id, __entry->fd, __entry->offset)
);

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)
		__field(size_t, extra_buffers_size)
	),
	TP_fast_assign(
		__entry->debug_id = buf->debug_id;
		__entry->data_size = buf->data_size;
		__entry->offsets_size = buf->offsets_size;
		__entry->extra_buffers_size = buf->extra_buffers_size;
	),
	TP_printk("transaction=%d data_size=%zd offsets_size=%zd extra_buffers_size=%zd",
		  __entry->debug_id, __entry->data_size, __entry->offsets_size,
		  __entry->extra_buffers_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_alloc *alloc, bool allocate,
		 void __user *start, void __user *end),
	TP_ARGS(alloc, 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 = alloc->pid;
		__entry->allocate = allocate;
		__entry->offset = start - alloc->buffer;
		__entry->size = end - start;
	),
	TP_printk("proc=%d allocate=%d offset=%zu size=%zu",
		  __entry->proc, __entry->allocate,
		  __entry->offset, __entry->size)
);

DECLARE_EVENT_CLASS(binder_lru_page_class,
	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	TP_ARGS(alloc, page_index),
	TP_STRUCT__entry(
		__field(int, proc)
		__field(size_t, page_index)
	),
	TP_fast_assign(
		__entry->proc = alloc->pid;
		__entry->page_index = page_index;
	),
	TP_printk("proc=%d page_index=%zu",
		  __entry->proc, __entry->page_index)
);

DEFINE_EVENT(binder_lru_page_class, binder_alloc_lru_start,
	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	TP_ARGS(alloc, page_index));

DEFINE_EVENT(binder_lru_page_class, binder_alloc_lru_end,
	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	TP_ARGS(alloc, page_index));

DEFINE_EVENT(binder_lru_page_class, binder_free_lru_start,
	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	TP_ARGS(alloc, page_index));

DEFINE_EVENT(binder_lru_page_class, binder_free_lru_end,
	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	TP_ARGS(alloc, page_index));

DEFINE_EVENT(binder_lru_page_class, binder_alloc_page_start,
	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	TP_ARGS(alloc, page_index));

DEFINE_EVENT(binder_lru_page_class, binder_alloc_page_end,
	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	TP_ARGS(alloc, page_index));

DEFINE_EVENT(binder_lru_page_class, binder_unmap_user_start,
	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	TP_ARGS(alloc, page_index));

DEFINE_EVENT(binder_lru_page_class, binder_unmap_user_end,
	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	TP_ARGS(alloc, page_index));

DEFINE_EVENT(binder_lru_page_class, binder_unmap_kernel_start,
	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	TP_ARGS(alloc, page_index));

DEFINE_EVENT(binder_lru_page_class, binder_unmap_kernel_end,
	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	TP_ARGS(alloc, page_index));

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>
Commit	Line	Data
975a1ac9 AH	1	/*
	2	* Copyright (C) 2012 Google, Inc.
	3	*
	4	* This software is licensed under the terms of the GNU General Public
	5	* License version 2, as published by the Free Software Foundation, and
	6	* may be copied, distributed, and modified under those terms.
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	* GNU General Public License for more details.
	12	*
	13	*/
	14
	15	#undef TRACE_SYSTEM
	16	#define TRACE_SYSTEM binder
	17
	18	#if !defined(_BINDER_TRACE_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	19	#define _BINDER_TRACE_H
	20
	21	#include <linux/tracepoint.h>
	22
	23	struct binder_buffer;
	24	struct binder_node;
	25	struct binder_proc;
19c98724	26	struct binder_alloc;
372e3147	27	struct binder_ref_data;
975a1ac9 AH	28	struct binder_thread;
	29	struct binder_transaction;
	30
	31	TRACE_EVENT(binder_ioctl,
	32	TP_PROTO(unsigned int cmd, unsigned long arg),
	33	TP_ARGS(cmd, arg),
	34
	35	TP_STRUCT__entry(
	36	__field(unsigned int, cmd)
	37	__field(unsigned long, arg)
	38	),
	39	TP_fast_assign(
	40	__entry->cmd = cmd;
	41	__entry->arg = arg;
	42	),
	43	TP_printk("cmd=0x%x arg=0x%lx", __entry->cmd, __entry->arg)
	44	);
	45
	46	DECLARE_EVENT_CLASS(binder_lock_class,
	47	TP_PROTO(const char *tag),
	48	TP_ARGS(tag),
	49	TP_STRUCT__entry(
	50	__field(const char *, tag)
	51	),
	52	TP_fast_assign(
	53	__entry->tag = tag;
	54	),
	55	TP_printk("tag=%s", __entry->tag)
	56	);
	57
	58	#define DEFINE_BINDER_LOCK_EVENT(name) \
	59	DEFINE_EVENT(binder_lock_class, name, \
	60	TP_PROTO(const char *func), \
	61	TP_ARGS(func))
	62
	63	DEFINE_BINDER_LOCK_EVENT(binder_lock);
	64	DEFINE_BINDER_LOCK_EVENT(binder_locked);
	65	DEFINE_BINDER_LOCK_EVENT(binder_unlock);
	66
	67	DECLARE_EVENT_CLASS(binder_function_return_class,
	68	TP_PROTO(int ret),
	69	TP_ARGS(ret),
	70	TP_STRUCT__entry(
	71	__field(int, ret)
	72	),
	73	TP_fast_assign(
	74	__entry->ret = ret;
	75	),
	76	TP_printk("ret=%d", __entry->ret)
	77	);
	78
	79	#define DEFINE_BINDER_FUNCTION_RETURN_EVENT(name) \
	80	DEFINE_EVENT(binder_function_return_class, name, \
	81	TP_PROTO(int ret), \
	82	TP_ARGS(ret))
	83
	84	DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_ioctl_done);
	85	DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_write_done);
	86	DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_read_done);
	87
	88	TRACE_EVENT(binder_wait_for_work,
	89	TP_PROTO(bool proc_work, bool transaction_stack, bool thread_todo),
	90	TP_ARGS(proc_work, transaction_stack, thread_todo),
	91
92	TP_STRUCT__entry(
93	__field(bool, proc_work)
94	__field(bool, transaction_stack)
95	__field(bool, thread_todo)
96	),
97	TP_fast_assign(
98	__entry->proc_work = proc_work;
99	__entry->transaction_stack = transaction_stack;
100	__entry->thread_todo = thread_todo;
101	),
102	TP_printk("proc_work=%d transaction_stack=%d thread_todo=%d",
103	__entry->proc_work, __entry->transaction_stack,
104	__entry->thread_todo)
105	);
106
107	TRACE_EVENT(binder_transaction,
108	TP_PROTO(bool reply, struct binder_transaction *t,
109	struct binder_node *target_node),
110	TP_ARGS(reply, t, target_node),
111	TP_STRUCT__entry(
112	__field(int, debug_id)
113	__field(int, target_node)
114	__field(int, to_proc)
115	__field(int, to_thread)
116	__field(int, reply)
117	__field(unsigned int, code)
118	__field(unsigned int, flags)
119	),
120	TP_fast_assign(
121	__entry->debug_id = t->debug_id;
122	__entry->target_node = target_node ? target_node->debug_id : 0;
123	__entry->to_proc = t->to_proc->pid;
124	__entry->to_thread = t->to_thread ? t->to_thread->pid : 0;
125	__entry->reply = reply;
126	__entry->code = t->code;
127	__entry->flags = t->flags;
128	),
129	TP_printk("transaction=%d dest_node=%d dest_proc=%d dest_thread=%d reply=%d flags=0x%x code=0x%x",
130	__entry->debug_id, __entry->target_node,
131	__entry->to_proc, __entry->to_thread,
132	__entry->reply, __entry->flags, __entry->code)
133	);
134
135	TRACE_EVENT(binder_transaction_received,
136	TP_PROTO(struct binder_transaction *t),
137	TP_ARGS(t),
138
139	TP_STRUCT__entry(
140	__field(int, debug_id)
141	),
142	TP_fast_assign(
143	__entry->debug_id = t->debug_id;
144	),
145	TP_printk("transaction=%d", __entry->debug_id)
146	);
147
148	TRACE_EVENT(binder_transaction_node_to_ref,
149	TP_PROTO(struct binder_transaction t, struct binder_node node,
372e3147 TK	150	struct binder_ref_data *rdata),
372e3147 TK	151	TP_ARGS(t, node, rdata),
975a1ac9 AH	152
	153	TP_STRUCT__entry(
	154	__field(int, debug_id)
	155	__field(int, node_debug_id)
da49889d	156	__field(binder_uintptr_t, node_ptr)
975a1ac9 AH	157	__field(int, ref_debug_id)
	158	__field(uint32_t, ref_desc)
	159	),
	160	TP_fast_assign(
	161	__entry->debug_id = t->debug_id;
	162	__entry->node_debug_id = node->debug_id;
	163	__entry->node_ptr = node->ptr;
372e3147 TK	164	__entry->ref_debug_id = rdata->debug_id;
372e3147 TK	165	__entry->ref_desc = rdata->desc;
975a1ac9	166	),
da49889d AH	167	TP_printk("transaction=%d node=%d src_ptr=0x%016llx ==> dest_ref=%d dest_desc=%d",
	168	__entry->debug_id, __entry->node_debug_id,
	169	(u64)__entry->node_ptr,
975a1ac9 AH	170	__entry->ref_debug_id, __entry->ref_desc)
	171	);
	172
	173	TRACE_EVENT(binder_transaction_ref_to_node,
372e3147 TK	174	TP_PROTO(struct binder_transaction t, struct binder_node node,
	175	struct binder_ref_data *rdata),
	176	TP_ARGS(t, node, rdata),
975a1ac9 AH	177
	178	TP_STRUCT__entry(
	179	__field(int, debug_id)
	180	__field(int, ref_debug_id)
	181	__field(uint32_t, ref_desc)
	182	__field(int, node_debug_id)
da49889d	183	__field(binder_uintptr_t, node_ptr)
975a1ac9 AH	184	),
	185	TP_fast_assign(
	186	__entry->debug_id = t->debug_id;
372e3147 TK	187	__entry->ref_debug_id = rdata->debug_id;
	188	__entry->ref_desc = rdata->desc;
	189	__entry->node_debug_id = node->debug_id;
	190	__entry->node_ptr = node->ptr;
975a1ac9	191	),
da49889d	192	TP_printk("transaction=%d node=%d src_ref=%d src_desc=%d ==> dest_ptr=0x%016llx",
975a1ac9	193	__entry->debug_id, __entry->node_debug_id,
da49889d AH	194	__entry->ref_debug_id, __entry->ref_desc,
da49889d AH	195	(u64)__entry->node_ptr)
975a1ac9 AH	196	);
	197
	198	TRACE_EVENT(binder_transaction_ref_to_ref,
372e3147 TK	199	TP_PROTO(struct binder_transaction t, struct binder_node node,
	200	struct binder_ref_data *src_ref,
	201	struct binder_ref_data *dest_ref),
	202	TP_ARGS(t, node, src_ref, dest_ref),
975a1ac9 AH	203
	204	TP_STRUCT__entry(
	205	__field(int, debug_id)
	206	__field(int, node_debug_id)
	207	__field(int, src_ref_debug_id)
	208	__field(uint32_t, src_ref_desc)
	209	__field(int, dest_ref_debug_id)
	210	__field(uint32_t, dest_ref_desc)
	211	),
	212	TP_fast_assign(
	213	__entry->debug_id = t->debug_id;
372e3147	214	__entry->node_debug_id = node->debug_id;
975a1ac9 AH	215	__entry->src_ref_debug_id = src_ref->debug_id;
	216	__entry->src_ref_desc = src_ref->desc;
	217	__entry->dest_ref_debug_id = dest_ref->debug_id;
	218	__entry->dest_ref_desc = dest_ref->desc;
	219	),
	220	TP_printk("transaction=%d node=%d src_ref=%d src_desc=%d ==> dest_ref=%d dest_desc=%d",
	221	__entry->debug_id, __entry->node_debug_id,
	222	__entry->src_ref_debug_id, __entry->src_ref_desc,
	223	__entry->dest_ref_debug_id, __entry->dest_ref_desc)
	224	);
	225
44d8047f TK	226	TRACE_EVENT(binder_transaction_fd_send,
	227	TP_PROTO(struct binder_transaction *t, int fd, size_t offset),
	228	TP_ARGS(t, fd, offset),
975a1ac9 AH	229
	230	TP_STRUCT__entry(
	231	__field(int, debug_id)
44d8047f TK	232	__field(int, fd)
44d8047f TK	233	__field(size_t, offset)
975a1ac9 AH	234	),
	235	TP_fast_assign(
	236	__entry->debug_id = t->debug_id;
44d8047f TK	237	__entry->fd = fd;
44d8047f TK	238	__entry->offset = offset;
975a1ac9	239	),
44d8047f TK	240	TP_printk("transaction=%d src_fd=%d offset=%zu",
	241	__entry->debug_id, __entry->fd, __entry->offset)
	242	);
	243
	244	TRACE_EVENT(binder_transaction_fd_recv,
	245	TP_PROTO(struct binder_transaction *t, int fd, size_t offset),
	246	TP_ARGS(t, fd, offset),
	247
	248	TP_STRUCT__entry(
	249	__field(int, debug_id)
	250	__field(int, fd)
	251	__field(size_t, offset)
	252	),
	253	TP_fast_assign(
	254	__entry->debug_id = t->debug_id;
	255	__entry->fd = fd;
	256	__entry->offset = offset;
	257	),
	258	TP_printk("transaction=%d dest_fd=%d offset=%zu",
	259	__entry->debug_id, __entry->fd, __entry->offset)
975a1ac9 AH	260	);
	261
	262	DECLARE_EVENT_CLASS(binder_buffer_class,
	263	TP_PROTO(struct binder_buffer *buf),
	264	TP_ARGS(buf),
	265	TP_STRUCT__entry(
	266	__field(int, debug_id)
	267	__field(size_t, data_size)
	268	__field(size_t, offsets_size)
c8c64b39	269	__field(size_t, extra_buffers_size)
975a1ac9 AH	270	),
	271	TP_fast_assign(
	272	__entry->debug_id = buf->debug_id;
	273	__entry->data_size = buf->data_size;
	274	__entry->offsets_size = buf->offsets_size;
c8c64b39	275	__entry->extra_buffers_size = buf->extra_buffers_size;
975a1ac9	276	),
c8c64b39 SY	277	TP_printk("transaction=%d data_size=%zd offsets_size=%zd extra_buffers_size=%zd",
	278	__entry->debug_id, __entry->data_size, __entry->offsets_size,
	279	__entry->extra_buffers_size)
975a1ac9 AH	280	);
	281
	282	DEFINE_EVENT(binder_buffer_class, binder_transaction_alloc_buf,
	283	TP_PROTO(struct binder_buffer *buffer),
	284	TP_ARGS(buffer));
	285
	286	DEFINE_EVENT(binder_buffer_class, binder_transaction_buffer_release,
	287	TP_PROTO(struct binder_buffer *buffer),
	288	TP_ARGS(buffer));
	289
	290	DEFINE_EVENT(binder_buffer_class, binder_transaction_failed_buffer_release,
	291	TP_PROTO(struct binder_buffer *buffer),
	292	TP_ARGS(buffer));
	293
	294	TRACE_EVENT(binder_update_page_range,
19c98724	295	TP_PROTO(struct binder_alloc *alloc, bool allocate,
bde4a19f	296	void __user start, void __user end),
19c98724	297	TP_ARGS(alloc, allocate, start, end),
975a1ac9 AH	298	TP_STRUCT__entry(
	299	__field(int, proc)
	300	__field(bool, allocate)
	301	__field(size_t, offset)
	302	__field(size_t, size)
	303	),
	304	TP_fast_assign(
19c98724	305	__entry->proc = alloc->pid;
975a1ac9	306	__entry->allocate = allocate;
19c98724	307	__entry->offset = start - alloc->buffer;
975a1ac9 AH	308	__entry->size = end - start;
	309	),
	310	TP_printk("proc=%d allocate=%d offset=%zu size=%zu",
	311	__entry->proc, __entry->allocate,
	312	__entry->offset, __entry->size)
	313	);
	314
e41e164c SY	315	DECLARE_EVENT_CLASS(binder_lru_page_class,
	316	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	317	TP_ARGS(alloc, page_index),
	318	TP_STRUCT__entry(
	319	__field(int, proc)
	320	__field(size_t, page_index)
	321	),
	322	TP_fast_assign(
	323	__entry->proc = alloc->pid;
	324	__entry->page_index = page_index;
	325	),
	326	TP_printk("proc=%d page_index=%zu",
	327	__entry->proc, __entry->page_index)
	328	);
	329
	330	DEFINE_EVENT(binder_lru_page_class, binder_alloc_lru_start,
	331	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	332	TP_ARGS(alloc, page_index));
	333
	334	DEFINE_EVENT(binder_lru_page_class, binder_alloc_lru_end,
	335	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	336	TP_ARGS(alloc, page_index));
	337
	338	DEFINE_EVENT(binder_lru_page_class, binder_free_lru_start,
	339	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	340	TP_ARGS(alloc, page_index));
	341
	342	DEFINE_EVENT(binder_lru_page_class, binder_free_lru_end,
	343	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	344	TP_ARGS(alloc, page_index));
	345
	346	DEFINE_EVENT(binder_lru_page_class, binder_alloc_page_start,
	347	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	348	TP_ARGS(alloc, page_index));
	349
	350	DEFINE_EVENT(binder_lru_page_class, binder_alloc_page_end,
	351	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	352	TP_ARGS(alloc, page_index));
	353
	354	DEFINE_EVENT(binder_lru_page_class, binder_unmap_user_start,
	355	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	356	TP_ARGS(alloc, page_index));
	357
	358	DEFINE_EVENT(binder_lru_page_class, binder_unmap_user_end,
	359	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	360	TP_ARGS(alloc, page_index));
	361
	362	DEFINE_EVENT(binder_lru_page_class, binder_unmap_kernel_start,
	363	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	364	TP_ARGS(alloc, page_index));
	365
	366	DEFINE_EVENT(binder_lru_page_class, binder_unmap_kernel_end,
	367	TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
	368	TP_ARGS(alloc, page_index));
	369
975a1ac9 AH	370	TRACE_EVENT(binder_command,
	371	TP_PROTO(uint32_t cmd),
	372	TP_ARGS(cmd),
	373	TP_STRUCT__entry(
	374	__field(uint32_t, cmd)
	375	),
	376	TP_fast_assign(
	377	__entry->cmd = cmd;
	378	),
	379	TP_printk("cmd=0x%x %s",
	380	__entry->cmd,
	381	_IOC_NR(__entry->cmd) < ARRAY_SIZE(binder_command_strings) ?
	382	binder_command_strings[_IOC_NR(__entry->cmd)] :
	383	"unknown")
	384	);
	385
	386	TRACE_EVENT(binder_return,
	387	TP_PROTO(uint32_t cmd),
	388	TP_ARGS(cmd),
	389	TP_STRUCT__entry(
	390	__field(uint32_t, cmd)
	391	),
	392	TP_fast_assign(
	393	__entry->cmd = cmd;
	394	),
	395	TP_printk("cmd=0x%x %s",
	396	__entry->cmd,
	397	_IOC_NR(__entry->cmd) < ARRAY_SIZE(binder_return_strings) ?
	398	binder_return_strings[_IOC_NR(__entry->cmd)] :
	399	"unknown")
	400	);
	401
	402	#endif /* _BINDER_TRACE_H */
	403
	404	#undef TRACE_INCLUDE_PATH
	405	#undef TRACE_INCLUDE_FILE
	406	#define TRACE_INCLUDE_PATH .
	407	#define TRACE_INCLUDE_FILE binder_trace
	408	#include <trace/define_trace.h>