[mirror_ubuntu-zesty-kernel.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_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>
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;
	26	struct binder_ref;
	27	struct binder_thread;
	28	struct binder_transaction;
	29
	30	TRACE_EVENT(binder_ioctl,
	31	TP_PROTO(unsigned int cmd, unsigned long arg),
	32	TP_ARGS(cmd, arg),
	33
	34	TP_STRUCT__entry(
	35	__field(unsigned int, cmd)
	36	__field(unsigned long, arg)
	37	),
	38	TP_fast_assign(
	39	__entry->cmd = cmd;
	40	__entry->arg = arg;
	41	),
	42	TP_printk("cmd=0x%x arg=0x%lx", __entry->cmd, __entry->arg)
	43	);
	44
	45	DECLARE_EVENT_CLASS(binder_lock_class,
	46	TP_PROTO(const char *tag),
	47	TP_ARGS(tag),
	48	TP_STRUCT__entry(
	49	__field(const char *, tag)
	50	),
	51	TP_fast_assign(
	52	__entry->tag = tag;
	53	),
	54	TP_printk("tag=%s", __entry->tag)
	55	);
	56
	57	#define DEFINE_BINDER_LOCK_EVENT(name) \
	58	DEFINE_EVENT(binder_lock_class, name, \
	59	TP_PROTO(const char *func), \
	60	TP_ARGS(func))
	61
	62	DEFINE_BINDER_LOCK_EVENT(binder_lock);
	63	DEFINE_BINDER_LOCK_EVENT(binder_locked);
	64	DEFINE_BINDER_LOCK_EVENT(binder_unlock);
65
66	DECLARE_EVENT_CLASS(binder_function_return_class,
67	TP_PROTO(int ret),
68	TP_ARGS(ret),
69	TP_STRUCT__entry(
70	__field(int, ret)
71	),
72	TP_fast_assign(
73	__entry->ret = ret;
74	),
75	TP_printk("ret=%d", __entry->ret)
76	);
77
78	#define DEFINE_BINDER_FUNCTION_RETURN_EVENT(name) \
79	DEFINE_EVENT(binder_function_return_class, name, \
80	TP_PROTO(int ret), \
81	TP_ARGS(ret))
82
83	DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_ioctl_done);
84	DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_write_done);
85	DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_read_done);
86
87	TRACE_EVENT(binder_wait_for_work,
88	TP_PROTO(bool proc_work, bool transaction_stack, bool thread_todo),
89	TP_ARGS(proc_work, transaction_stack, thread_todo),
90
91	TP_STRUCT__entry(
92	__field(bool, proc_work)
93	__field(bool, transaction_stack)
94	__field(bool, thread_todo)
95	),
96	TP_fast_assign(
97	__entry->proc_work = proc_work;
98	__entry->transaction_stack = transaction_stack;
99	__entry->thread_todo = thread_todo;
100	),
101	TP_printk("proc_work=%d transaction_stack=%d thread_todo=%d",
102	__entry->proc_work, __entry->transaction_stack,
103	__entry->thread_todo)
104	);
105
106	TRACE_EVENT(binder_transaction,
107	TP_PROTO(bool reply, struct binder_transaction *t,
108	struct binder_node *target_node),
109	TP_ARGS(reply, t, target_node),
110	TP_STRUCT__entry(
111	__field(int, debug_id)
112	__field(int, target_node)
113	__field(int, to_proc)
114	__field(int, to_thread)
115	__field(int, reply)
116	__field(unsigned int, code)
117	__field(unsigned int, flags)
118	),
119	TP_fast_assign(
120	__entry->debug_id = t->debug_id;
121	__entry->target_node = target_node ? target_node->debug_id : 0;
122	__entry->to_proc = t->to_proc->pid;
123	__entry->to_thread = t->to_thread ? t->to_thread->pid : 0;
124	__entry->reply = reply;
125	__entry->code = t->code;
126	__entry->flags = t->flags;
127	),
128	TP_printk("transaction=%d dest_node=%d dest_proc=%d dest_thread=%d reply=%d flags=0x%x code=0x%x",
129	__entry->debug_id, __entry->target_node,
130	__entry->to_proc, __entry->to_thread,
131	__entry->reply, __entry->flags, __entry->code)
132	);
133
134	TRACE_EVENT(binder_transaction_received,
135	TP_PROTO(struct binder_transaction *t),
136	TP_ARGS(t),
137
138	TP_STRUCT__entry(
139	__field(int, debug_id)
140	),
141	TP_fast_assign(
142	__entry->debug_id = t->debug_id;
143	),
144	TP_printk("transaction=%d", __entry->debug_id)
145	);
146
147	TRACE_EVENT(binder_transaction_node_to_ref,
148	TP_PROTO(struct binder_transaction t, struct binder_node node,
149	struct binder_ref *ref),
150	TP_ARGS(t, node, ref),
151
152	TP_STRUCT__entry(
153	__field(int, debug_id)
154	__field(int, node_debug_id)
da49889d	155	__field(binder_uintptr_t, node_ptr)
975a1ac9 AH	156	__field(int, ref_debug_id)
	157	__field(uint32_t, ref_desc)
	158	),
	159	TP_fast_assign(
	160	__entry->debug_id = t->debug_id;
	161	__entry->node_debug_id = node->debug_id;
	162	__entry->node_ptr = node->ptr;
	163	__entry->ref_debug_id = ref->debug_id;
	164	__entry->ref_desc = ref->desc;
	165	),
da49889d AH	166	TP_printk("transaction=%d node=%d src_ptr=0x%016llx ==> dest_ref=%d dest_desc=%d",
	167	__entry->debug_id, __entry->node_debug_id,
	168	(u64)__entry->node_ptr,
975a1ac9 AH	169	__entry->ref_debug_id, __entry->ref_desc)
	170	);
	171
	172	TRACE_EVENT(binder_transaction_ref_to_node,
	173	TP_PROTO(struct binder_transaction t, struct binder_ref ref),
	174	TP_ARGS(t, ref),
	175
	176	TP_STRUCT__entry(
	177	__field(int, debug_id)
	178	__field(int, ref_debug_id)
	179	__field(uint32_t, ref_desc)
	180	__field(int, node_debug_id)
da49889d	181	__field(binder_uintptr_t, node_ptr)
975a1ac9 AH	182	),
	183	TP_fast_assign(
	184	__entry->debug_id = t->debug_id;
	185	__entry->ref_debug_id = ref->debug_id;
	186	__entry->ref_desc = ref->desc;
	187	__entry->node_debug_id = ref->node->debug_id;
	188	__entry->node_ptr = ref->node->ptr;
	189	),
da49889d	190	TP_printk("transaction=%d node=%d src_ref=%d src_desc=%d ==> dest_ptr=0x%016llx",
975a1ac9	191	__entry->debug_id, __entry->node_debug_id,
da49889d AH	192	__entry->ref_debug_id, __entry->ref_desc,
da49889d AH	193	(u64)__entry->node_ptr)
975a1ac9 AH	194	);
	195
	196	TRACE_EVENT(binder_transaction_ref_to_ref,
	197	TP_PROTO(struct binder_transaction t, struct binder_ref src_ref,
	198	struct binder_ref *dest_ref),
	199	TP_ARGS(t, src_ref, dest_ref),
	200
	201	TP_STRUCT__entry(
	202	__field(int, debug_id)
	203	__field(int, node_debug_id)
	204	__field(int, src_ref_debug_id)
	205	__field(uint32_t, src_ref_desc)
	206	__field(int, dest_ref_debug_id)
	207	__field(uint32_t, dest_ref_desc)
	208	),
	209	TP_fast_assign(
	210	__entry->debug_id = t->debug_id;
	211	__entry->node_debug_id = src_ref->node->debug_id;
	212	__entry->src_ref_debug_id = src_ref->debug_id;
	213	__entry->src_ref_desc = src_ref->desc;
	214	__entry->dest_ref_debug_id = dest_ref->debug_id;
	215	__entry->dest_ref_desc = dest_ref->desc;
	216	),
	217	TP_printk("transaction=%d node=%d src_ref=%d src_desc=%d ==> dest_ref=%d dest_desc=%d",
	218	__entry->debug_id, __entry->node_debug_id,
	219	__entry->src_ref_debug_id, __entry->src_ref_desc,
	220	__entry->dest_ref_debug_id, __entry->dest_ref_desc)
	221	);
	222
	223	TRACE_EVENT(binder_transaction_fd,
	224	TP_PROTO(struct binder_transaction *t, int src_fd, int dest_fd),
	225	TP_ARGS(t, src_fd, dest_fd),
	226
	227	TP_STRUCT__entry(
	228	__field(int, debug_id)
	229	__field(int, src_fd)
	230	__field(int, dest_fd)
	231	),
	232	TP_fast_assign(
	233	__entry->debug_id = t->debug_id;
	234	__entry->src_fd = src_fd;
	235	__entry->dest_fd = dest_fd;
	236	),
	237	TP_printk("transaction=%d src_fd=%d ==> dest_fd=%d",
	238	__entry->debug_id, __entry->src_fd, __entry->dest_fd)
	239	);
	240
	241	DECLARE_EVENT_CLASS(binder_buffer_class,
	242	TP_PROTO(struct binder_buffer *buf),
	243	TP_ARGS(buf),
	244	TP_STRUCT__entry(
	245	__field(int, debug_id)
	246	__field(size_t, data_size)
	247	__field(size_t, offsets_size)
	248	),
	249	TP_fast_assign(
	250	__entry->debug_id = buf->debug_id;
	251	__entry->data_size = buf->data_size;
	252	__entry->offsets_size = buf->offsets_size;
	253	),
	254	TP_printk("transaction=%d data_size=%zd offsets_size=%zd",
	255	__entry->debug_id, __entry->data_size, __entry->offsets_size)
	256	);
	257
258	DEFINE_EVENT(binder_buffer_class, binder_transaction_alloc_buf,
259	TP_PROTO(struct binder_buffer *buffer),
260	TP_ARGS(buffer));
261
262	DEFINE_EVENT(binder_buffer_class, binder_transaction_buffer_release,
263	TP_PROTO(struct binder_buffer *buffer),
264	TP_ARGS(buffer));
265
266	DEFINE_EVENT(binder_buffer_class, binder_transaction_failed_buffer_release,
267	TP_PROTO(struct binder_buffer *buffer),
268	TP_ARGS(buffer));
269
270	TRACE_EVENT(binder_update_page_range,
271	TP_PROTO(struct binder_proc *proc, bool allocate,
272	void start, void end),
273	TP_ARGS(proc, allocate, start, end),
274	TP_STRUCT__entry(
275	__field(int, proc)
276	__field(bool, allocate)
277	__field(size_t, offset)
278	__field(size_t, size)
279	),
280	TP_fast_assign(
281	__entry->proc = proc->pid;
282	__entry->allocate = allocate;
283	__entry->offset = start - proc->buffer;
284	__entry->size = end - start;
285	),
286	TP_printk("proc=%d allocate=%d offset=%zu size=%zu",
287	__entry->proc, __entry->allocate,
288	__entry->offset, __entry->size)
289	);
290
291	TRACE_EVENT(binder_command,
292	TP_PROTO(uint32_t cmd),
293	TP_ARGS(cmd),
294	TP_STRUCT__entry(
295	__field(uint32_t, cmd)
296	),
297	TP_fast_assign(
298	__entry->cmd = cmd;
299	),
300	TP_printk("cmd=0x%x %s",
301	__entry->cmd,
302	_IOC_NR(__entry->cmd) < ARRAY_SIZE(binder_command_strings) ?
303	binder_command_strings[_IOC_NR(__entry->cmd)] :
304	"unknown")
305	);
306
307	TRACE_EVENT(binder_return,
308	TP_PROTO(uint32_t cmd),
309	TP_ARGS(cmd),
310	TP_STRUCT__entry(
311	__field(uint32_t, cmd)
312	),
313	TP_fast_assign(
314	__entry->cmd = cmd;
315	),
316	TP_printk("cmd=0x%x %s",
317	__entry->cmd,
318	_IOC_NR(__entry->cmd) < ARRAY_SIZE(binder_return_strings) ?
319	binder_return_strings[_IOC_NR(__entry->cmd)] :
320	"unknown")
321	);
322
323	#endif /* _BINDER_TRACE_H */
324
325	#undef TRACE_INCLUDE_PATH
326	#undef TRACE_INCLUDE_FILE
327	#define TRACE_INCLUDE_PATH .
328	#define TRACE_INCLUDE_FILE binder_trace
329	#include <trace/define_trace.h>