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