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_transaction,
99 TP_PROTO(bool reply, struct binder_transaction *t,
100 struct binder_node *target_node),
101 TP_ARGS(reply, t, target_node),
102 TP_STRUCT__entry(
103 __field(int, debug_id)
104 __field(int, target_node)
105 __field(int, to_proc)
106 __field(int, to_thread)
107 __field(int, reply)
108 __field(unsigned int, code)
109 __field(unsigned int, flags)
110 ),
111 TP_fast_assign(
112 __entry->debug_id = t->debug_id;
113 __entry->target_node = target_node ? target_node->debug_id : 0;
114 __entry->to_proc = t->to_proc->pid;
115 __entry->to_thread = t->to_thread ? t->to_thread->pid : 0;
116 __entry->reply = reply;
117 __entry->code = t->code;
118 __entry->flags = t->flags;
119 ),
120 TP_printk("transaction=%d dest_node=%d dest_proc=%d dest_thread=%d reply=%d flags=0x%x code=0x%x",
121 __entry->debug_id, __entry->target_node,
122 __entry->to_proc, __entry->to_thread,
123 __entry->reply, __entry->flags, __entry->code)
124);
125
126TRACE_EVENT(binder_transaction_received,
127 TP_PROTO(struct binder_transaction *t),
128 TP_ARGS(t),
129
130 TP_STRUCT__entry(
131 __field(int, debug_id)
132 ),
133 TP_fast_assign(
134 __entry->debug_id = t->debug_id;
135 ),
136 TP_printk("transaction=%d", __entry->debug_id)
137);
138
139TRACE_EVENT(binder_transaction_node_to_ref,
140 TP_PROTO(struct binder_transaction *t, struct binder_node *node,
141 struct binder_ref_data *rdata),
142 TP_ARGS(t, node, rdata),
143
144 TP_STRUCT__entry(
145 __field(int, debug_id)
146 __field(int, node_debug_id)
147 __field(binder_uintptr_t, node_ptr)
148 __field(int, ref_debug_id)
149 __field(uint32_t, ref_desc)
150 ),
151 TP_fast_assign(
152 __entry->debug_id = t->debug_id;
153 __entry->node_debug_id = node->debug_id;
154 __entry->node_ptr = node->ptr;
155 __entry->ref_debug_id = rdata->debug_id;
156 __entry->ref_desc = rdata->desc;
157 ),
158 TP_printk("transaction=%d node=%d src_ptr=0x%016llx ==> dest_ref=%d dest_desc=%d",
159 __entry->debug_id, __entry->node_debug_id,
160 (u64)__entry->node_ptr,
161 __entry->ref_debug_id, __entry->ref_desc)
162);
163
164TRACE_EVENT(binder_transaction_ref_to_node,
165 TP_PROTO(struct binder_transaction *t, struct binder_node *node,
166 struct binder_ref_data *rdata),
167 TP_ARGS(t, node, rdata),
168
169 TP_STRUCT__entry(
170 __field(int, debug_id)
171 __field(int, ref_debug_id)
172 __field(uint32_t, ref_desc)
173 __field(int, node_debug_id)
174 __field(binder_uintptr_t, node_ptr)
175 ),
176 TP_fast_assign(
177 __entry->debug_id = t->debug_id;
178 __entry->ref_debug_id = rdata->debug_id;
179 __entry->ref_desc = rdata->desc;
180 __entry->node_debug_id = node->debug_id;
181 __entry->node_ptr = node->ptr;
182 ),
183 TP_printk("transaction=%d node=%d src_ref=%d src_desc=%d ==> dest_ptr=0x%016llx",
184 __entry->debug_id, __entry->node_debug_id,
185 __entry->ref_debug_id, __entry->ref_desc,
186 (u64)__entry->node_ptr)
187);
188
189TRACE_EVENT(binder_transaction_ref_to_ref,
190 TP_PROTO(struct binder_transaction *t, struct binder_node *node,
191 struct binder_ref_data *src_ref,
192 struct binder_ref_data *dest_ref),
193 TP_ARGS(t, node, src_ref, dest_ref),
194
195 TP_STRUCT__entry(
196 __field(int, debug_id)
197 __field(int, node_debug_id)
198 __field(int, src_ref_debug_id)
199 __field(uint32_t, src_ref_desc)
200 __field(int, dest_ref_debug_id)
201 __field(uint32_t, dest_ref_desc)
202 ),
203 TP_fast_assign(
204 __entry->debug_id = t->debug_id;
205 __entry->node_debug_id = node->debug_id;
206 __entry->src_ref_debug_id = src_ref->debug_id;
207 __entry->src_ref_desc = src_ref->desc;
208 __entry->dest_ref_debug_id = dest_ref->debug_id;
209 __entry->dest_ref_desc = dest_ref->desc;
210 ),
211 TP_printk("transaction=%d node=%d src_ref=%d src_desc=%d ==> dest_ref=%d dest_desc=%d",
212 __entry->debug_id, __entry->node_debug_id,
213 __entry->src_ref_debug_id, __entry->src_ref_desc,
214 __entry->dest_ref_debug_id, __entry->dest_ref_desc)
215);
216
217TRACE_EVENT(binder_transaction_fd_send,
218 TP_PROTO(struct binder_transaction *t, int fd, size_t offset),
219 TP_ARGS(t, fd, offset),
220
221 TP_STRUCT__entry(
222 __field(int, debug_id)
223 __field(int, fd)
224 __field(size_t, offset)
225 ),
226 TP_fast_assign(
227 __entry->debug_id = t->debug_id;
228 __entry->fd = fd;
229 __entry->offset = offset;
230 ),
231 TP_printk("transaction=%d src_fd=%d offset=%zu",
232 __entry->debug_id, __entry->fd, __entry->offset)
233);
234
235TRACE_EVENT(binder_transaction_fd_recv,
236 TP_PROTO(struct binder_transaction *t, int fd, size_t offset),
237 TP_ARGS(t, fd, offset),
238
239 TP_STRUCT__entry(
240 __field(int, debug_id)
241 __field(int, fd)
242 __field(size_t, offset)
243 ),
244 TP_fast_assign(
245 __entry->debug_id = t->debug_id;
246 __entry->fd = fd;
247 __entry->offset = offset;
248 ),
249 TP_printk("transaction=%d dest_fd=%d offset=%zu",
250 __entry->debug_id, __entry->fd, __entry->offset)
251);
252
253DECLARE_EVENT_CLASS(binder_buffer_class,
254 TP_PROTO(struct binder_buffer *buf),
255 TP_ARGS(buf),
256 TP_STRUCT__entry(
257 __field(int, debug_id)
258 __field(size_t, data_size)
259 __field(size_t, offsets_size)
260 __field(size_t, extra_buffers_size)
261 ),
262 TP_fast_assign(
263 __entry->debug_id = buf->debug_id;
264 __entry->data_size = buf->data_size;
265 __entry->offsets_size = buf->offsets_size;
266 __entry->extra_buffers_size = buf->extra_buffers_size;
267 ),
268 TP_printk("transaction=%d data_size=%zd offsets_size=%zd extra_buffers_size=%zd",
269 __entry->debug_id, __entry->data_size, __entry->offsets_size,
270 __entry->extra_buffers_size)
271);
272
273DEFINE_EVENT(binder_buffer_class, binder_transaction_alloc_buf,
274 TP_PROTO(struct binder_buffer *buffer),
275 TP_ARGS(buffer));
276
277DEFINE_EVENT(binder_buffer_class, binder_transaction_buffer_release,
278 TP_PROTO(struct binder_buffer *buffer),
279 TP_ARGS(buffer));
280
281DEFINE_EVENT(binder_buffer_class, binder_transaction_failed_buffer_release,
282 TP_PROTO(struct binder_buffer *buffer),
283 TP_ARGS(buffer));
284
285TRACE_EVENT(binder_update_page_range,
286 TP_PROTO(struct binder_alloc *alloc, bool allocate,
287 void __user *start, void __user *end),
288 TP_ARGS(alloc, allocate, start, end),
289 TP_STRUCT__entry(
290 __field(int, proc)
291 __field(bool, allocate)
292 __field(size_t, offset)
293 __field(size_t, size)
294 ),
295 TP_fast_assign(
296 __entry->proc = alloc->pid;
297 __entry->allocate = allocate;
298 __entry->offset = start - alloc->buffer;
299 __entry->size = end - start;
300 ),
301 TP_printk("proc=%d allocate=%d offset=%zu size=%zu",
302 __entry->proc, __entry->allocate,
303 __entry->offset, __entry->size)
304);
305
306DECLARE_EVENT_CLASS(binder_lru_page_class,
307 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
308 TP_ARGS(alloc, page_index),
309 TP_STRUCT__entry(
310 __field(int, proc)
311 __field(size_t, page_index)
312 ),
313 TP_fast_assign(
314 __entry->proc = alloc->pid;
315 __entry->page_index = page_index;
316 ),
317 TP_printk("proc=%d page_index=%zu",
318 __entry->proc, __entry->page_index)
319);
320
321DEFINE_EVENT(binder_lru_page_class, binder_alloc_lru_start,
322 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
323 TP_ARGS(alloc, page_index));
324
325DEFINE_EVENT(binder_lru_page_class, binder_alloc_lru_end,
326 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
327 TP_ARGS(alloc, page_index));
328
329DEFINE_EVENT(binder_lru_page_class, binder_free_lru_start,
330 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
331 TP_ARGS(alloc, page_index));
332
333DEFINE_EVENT(binder_lru_page_class, binder_free_lru_end,
334 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
335 TP_ARGS(alloc, page_index));
336
337DEFINE_EVENT(binder_lru_page_class, binder_alloc_page_start,
338 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
339 TP_ARGS(alloc, page_index));
340
341DEFINE_EVENT(binder_lru_page_class, binder_alloc_page_end,
342 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
343 TP_ARGS(alloc, page_index));
344
345DEFINE_EVENT(binder_lru_page_class, binder_unmap_user_start,
346 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
347 TP_ARGS(alloc, page_index));
348
349DEFINE_EVENT(binder_lru_page_class, binder_unmap_user_end,
350 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
351 TP_ARGS(alloc, page_index));
352
353DEFINE_EVENT(binder_lru_page_class, binder_unmap_kernel_start,
354 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
355 TP_ARGS(alloc, page_index));
356
357DEFINE_EVENT(binder_lru_page_class, binder_unmap_kernel_end,
358 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
359 TP_ARGS(alloc, page_index));
360
361TRACE_EVENT(binder_command,
362 TP_PROTO(uint32_t cmd),
363 TP_ARGS(cmd),
364 TP_STRUCT__entry(
365 __field(uint32_t, cmd)
366 ),
367 TP_fast_assign(
368 __entry->cmd = cmd;
369 ),
370 TP_printk("cmd=0x%x %s",
371 __entry->cmd,
372 _IOC_NR(__entry->cmd) < ARRAY_SIZE(binder_command_strings) ?
373 binder_command_strings[_IOC_NR(__entry->cmd)] :
374 "unknown")
375);
376
377TRACE_EVENT(binder_return,
378 TP_PROTO(uint32_t cmd),
379 TP_ARGS(cmd),
380 TP_STRUCT__entry(
381 __field(uint32_t, cmd)
382 ),
383 TP_fast_assign(
384 __entry->cmd = cmd;
385 ),
386 TP_printk("cmd=0x%x %s",
387 __entry->cmd,
388 _IOC_NR(__entry->cmd) < ARRAY_SIZE(binder_return_strings) ?
389 binder_return_strings[_IOC_NR(__entry->cmd)] :
390 "unknown")
391);
392
393#endif /* _BINDER_TRACE_H */
394
395#undef TRACE_INCLUDE_PATH
396#undef TRACE_INCLUDE_FILE
397#define TRACE_INCLUDE_PATH .
398#define TRACE_INCLUDE_FILE binder_trace
399#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_alloc;
27struct binder_ref_data;
28struct binder_thread;
29struct binder_transaction;
30
31TRACE_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
46DECLARE_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) \
59DEFINE_EVENT(binder_lock_class, name, \
60 TP_PROTO(const char *func), \
61 TP_ARGS(func))
62
63DEFINE_BINDER_LOCK_EVENT(binder_lock);
64DEFINE_BINDER_LOCK_EVENT(binder_locked);
65DEFINE_BINDER_LOCK_EVENT(binder_unlock);
66
67DECLARE_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) \
80DEFINE_EVENT(binder_function_return_class, name, \
81 TP_PROTO(int ret), \
82 TP_ARGS(ret))
83
84DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_ioctl_done);
85DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_write_done);
86DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_read_done);
87
88TRACE_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
107TRACE_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
135TRACE_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
148TRACE_EVENT(binder_transaction_node_to_ref,
149 TP_PROTO(struct binder_transaction *t, struct binder_node *node,
150 struct binder_ref_data *rdata),
151 TP_ARGS(t, node, rdata),
152
153 TP_STRUCT__entry(
154 __field(int, debug_id)
155 __field(int, node_debug_id)
156 __field(binder_uintptr_t, node_ptr)
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;
164 __entry->ref_debug_id = rdata->debug_id;
165 __entry->ref_desc = rdata->desc;
166 ),
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,
170 __entry->ref_debug_id, __entry->ref_desc)
171);
172
173TRACE_EVENT(binder_transaction_ref_to_node,
174 TP_PROTO(struct binder_transaction *t, struct binder_node *node,
175 struct binder_ref_data *rdata),
176 TP_ARGS(t, node, rdata),
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)
183 __field(binder_uintptr_t, node_ptr)
184 ),
185 TP_fast_assign(
186 __entry->debug_id = t->debug_id;
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;
191 ),
192 TP_printk("transaction=%d node=%d src_ref=%d src_desc=%d ==> dest_ptr=0x%016llx",
193 __entry->debug_id, __entry->node_debug_id,
194 __entry->ref_debug_id, __entry->ref_desc,
195 (u64)__entry->node_ptr)
196);
197
198TRACE_EVENT(binder_transaction_ref_to_ref,
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),
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;
214 __entry->node_debug_id = node->debug_id;
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
226TRACE_EVENT(binder_transaction_fd,
227 TP_PROTO(struct binder_transaction *t, int src_fd, int dest_fd),
228 TP_ARGS(t, src_fd, dest_fd),
229
230 TP_STRUCT__entry(
231 __field(int, debug_id)
232 __field(int, src_fd)
233 __field(int, dest_fd)
234 ),
235 TP_fast_assign(
236 __entry->debug_id = t->debug_id;
237 __entry->src_fd = src_fd;
238 __entry->dest_fd = dest_fd;
239 ),
240 TP_printk("transaction=%d src_fd=%d ==> dest_fd=%d",
241 __entry->debug_id, __entry->src_fd, __entry->dest_fd)
242);
243
244DECLARE_EVENT_CLASS(binder_buffer_class,
245 TP_PROTO(struct binder_buffer *buf),
246 TP_ARGS(buf),
247 TP_STRUCT__entry(
248 __field(int, debug_id)
249 __field(size_t, data_size)
250 __field(size_t, offsets_size)
251 ),
252 TP_fast_assign(
253 __entry->debug_id = buf->debug_id;
254 __entry->data_size = buf->data_size;
255 __entry->offsets_size = buf->offsets_size;
256 ),
257 TP_printk("transaction=%d data_size=%zd offsets_size=%zd",
258 __entry->debug_id, __entry->data_size, __entry->offsets_size)
259);
260
261DEFINE_EVENT(binder_buffer_class, binder_transaction_alloc_buf,
262 TP_PROTO(struct binder_buffer *buffer),
263 TP_ARGS(buffer));
264
265DEFINE_EVENT(binder_buffer_class, binder_transaction_buffer_release,
266 TP_PROTO(struct binder_buffer *buffer),
267 TP_ARGS(buffer));
268
269DEFINE_EVENT(binder_buffer_class, binder_transaction_failed_buffer_release,
270 TP_PROTO(struct binder_buffer *buffer),
271 TP_ARGS(buffer));
272
273TRACE_EVENT(binder_update_page_range,
274 TP_PROTO(struct binder_alloc *alloc, bool allocate,
275 void *start, void *end),
276 TP_ARGS(alloc, allocate, start, end),
277 TP_STRUCT__entry(
278 __field(int, proc)
279 __field(bool, allocate)
280 __field(size_t, offset)
281 __field(size_t, size)
282 ),
283 TP_fast_assign(
284 __entry->proc = alloc->pid;
285 __entry->allocate = allocate;
286 __entry->offset = start - alloc->buffer;
287 __entry->size = end - start;
288 ),
289 TP_printk("proc=%d allocate=%d offset=%zu size=%zu",
290 __entry->proc, __entry->allocate,
291 __entry->offset, __entry->size)
292);
293
294DECLARE_EVENT_CLASS(binder_lru_page_class,
295 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
296 TP_ARGS(alloc, page_index),
297 TP_STRUCT__entry(
298 __field(int, proc)
299 __field(size_t, page_index)
300 ),
301 TP_fast_assign(
302 __entry->proc = alloc->pid;
303 __entry->page_index = page_index;
304 ),
305 TP_printk("proc=%d page_index=%zu",
306 __entry->proc, __entry->page_index)
307);
308
309DEFINE_EVENT(binder_lru_page_class, binder_alloc_lru_start,
310 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
311 TP_ARGS(alloc, page_index));
312
313DEFINE_EVENT(binder_lru_page_class, binder_alloc_lru_end,
314 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
315 TP_ARGS(alloc, page_index));
316
317DEFINE_EVENT(binder_lru_page_class, binder_free_lru_start,
318 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
319 TP_ARGS(alloc, page_index));
320
321DEFINE_EVENT(binder_lru_page_class, binder_free_lru_end,
322 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
323 TP_ARGS(alloc, page_index));
324
325DEFINE_EVENT(binder_lru_page_class, binder_alloc_page_start,
326 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
327 TP_ARGS(alloc, page_index));
328
329DEFINE_EVENT(binder_lru_page_class, binder_alloc_page_end,
330 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
331 TP_ARGS(alloc, page_index));
332
333DEFINE_EVENT(binder_lru_page_class, binder_unmap_user_start,
334 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
335 TP_ARGS(alloc, page_index));
336
337DEFINE_EVENT(binder_lru_page_class, binder_unmap_user_end,
338 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
339 TP_ARGS(alloc, page_index));
340
341DEFINE_EVENT(binder_lru_page_class, binder_unmap_kernel_start,
342 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
343 TP_ARGS(alloc, page_index));
344
345DEFINE_EVENT(binder_lru_page_class, binder_unmap_kernel_end,
346 TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
347 TP_ARGS(alloc, page_index));
348
349TRACE_EVENT(binder_command,
350 TP_PROTO(uint32_t cmd),
351 TP_ARGS(cmd),
352 TP_STRUCT__entry(
353 __field(uint32_t, cmd)
354 ),
355 TP_fast_assign(
356 __entry->cmd = cmd;
357 ),
358 TP_printk("cmd=0x%x %s",
359 __entry->cmd,
360 _IOC_NR(__entry->cmd) < ARRAY_SIZE(binder_command_strings) ?
361 binder_command_strings[_IOC_NR(__entry->cmd)] :
362 "unknown")
363);
364
365TRACE_EVENT(binder_return,
366 TP_PROTO(uint32_t cmd),
367 TP_ARGS(cmd),
368 TP_STRUCT__entry(
369 __field(uint32_t, cmd)
370 ),
371 TP_fast_assign(
372 __entry->cmd = cmd;
373 ),
374 TP_printk("cmd=0x%x %s",
375 __entry->cmd,
376 _IOC_NR(__entry->cmd) < ARRAY_SIZE(binder_return_strings) ?
377 binder_return_strings[_IOC_NR(__entry->cmd)] :
378 "unknown")
379);
380
381#endif /* _BINDER_TRACE_H */
382
383#undef TRACE_INCLUDE_PATH
384#undef TRACE_INCLUDE_FILE
385#define TRACE_INCLUDE_PATH .
386#define TRACE_INCLUDE_FILE binder_trace
387#include <trace/define_trace.h>