drivers/android/binder_trace.h

0001 /* SPDX-License-Identifier: GPL-2.0-only */
0002 /*
0003  * Copyright (C) 2012 Google, Inc.
0004  */
0005
0006 #undef TRACE_SYSTEM
0007 #define TRACE_SYSTEM binder
0008
0009 #if !defined(_BINDER_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
0010 #define _BINDER_TRACE_H
0011
0012 #include <linux/tracepoint.h>
0013
0014 struct binder_buffer;
0015 struct binder_node;
0016 struct binder_proc;
0017 struct binder_alloc;
0018 struct binder_ref_data;
0019 struct binder_thread;
0020 struct binder_transaction;
0021
0022 TRACE_EVENT(binder_ioctl,
0023     TP_PROTO(unsigned int cmd, unsigned long arg),
0024     TP_ARGS(cmd, arg),
0025
0026     TP_STRUCT__entry(
0027         __field(unsigned int, cmd)
0028         __field(unsigned long, arg)
0029     ),
0030     TP_fast_assign(
0031         __entry->cmd = cmd;
0032         __entry->arg = arg;
0033     ),
0034     TP_printk("cmd=0x%x arg=0x%lx", __entry->cmd, __entry->arg)
0035 );
0036
0037 DECLARE_EVENT_CLASS(binder_lock_class,
0038     TP_PROTO(const char *tag),
0039     TP_ARGS(tag),
0040     TP_STRUCT__entry(
0041         __field(const char *, tag)
0042     ),
0043     TP_fast_assign(
0044         __entry->tag = tag;
0045     ),
0046     TP_printk("tag=%s", __entry->tag)
0047 );
0048
0049 #define DEFINE_BINDER_LOCK_EVENT(name)  \
0050 DEFINE_EVENT(binder_lock_class, name,   \
0051     TP_PROTO(const char *func), \
0052     TP_ARGS(func))
0053
0054 DEFINE_BINDER_LOCK_EVENT(binder_lock);
0055 DEFINE_BINDER_LOCK_EVENT(binder_locked);
0056 DEFINE_BINDER_LOCK_EVENT(binder_unlock);
0057
0058 DECLARE_EVENT_CLASS(binder_function_return_class,
0059     TP_PROTO(int ret),
0060     TP_ARGS(ret),
0061     TP_STRUCT__entry(
0062         __field(int, ret)
0063     ),
0064     TP_fast_assign(
0065         __entry->ret = ret;
0066     ),
0067     TP_printk("ret=%d", __entry->ret)
0068 );
0069
0070 #define DEFINE_BINDER_FUNCTION_RETURN_EVENT(name)   \
0071 DEFINE_EVENT(binder_function_return_class, name,    \
0072     TP_PROTO(int ret), \
0073     TP_ARGS(ret))
0074
0075 DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_ioctl_done);
0076 DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_write_done);
0077 DEFINE_BINDER_FUNCTION_RETURN_EVENT(binder_read_done);
0078
0079 TRACE_EVENT(binder_wait_for_work,
0080     TP_PROTO(bool proc_work, bool transaction_stack, bool thread_todo),
0081     TP_ARGS(proc_work, transaction_stack, thread_todo),
0082
0083     TP_STRUCT__entry(
0084         __field(bool, proc_work)
0085         __field(bool, transaction_stack)
0086         __field(bool, thread_todo)
0087     ),
0088     TP_fast_assign(
0089         __entry->proc_work = proc_work;
0090         __entry->transaction_stack = transaction_stack;
0091         __entry->thread_todo = thread_todo;
0092     ),
0093     TP_printk("proc_work=%d transaction_stack=%d thread_todo=%d",
0094           __entry->proc_work, __entry->transaction_stack,
0095           __entry->thread_todo)
0096 );
0097
0098 TRACE_EVENT(binder_txn_latency_free,
0099     TP_PROTO(struct binder_transaction *t,
0100          int from_proc, int from_thread,
0101          int to_proc, int to_thread),
0102     TP_ARGS(t, from_proc, from_thread, to_proc, to_thread),
0103     TP_STRUCT__entry(
0104         __field(int, debug_id)
0105         __field(int, from_proc)
0106         __field(int, from_thread)
0107         __field(int, to_proc)
0108         __field(int, to_thread)
0109         __field(unsigned int, code)
0110         __field(unsigned int, flags)
0111     ),
0112     TP_fast_assign(
0113         __entry->debug_id = t->debug_id;
0114         __entry->from_proc = from_proc;
0115         __entry->from_thread = from_thread;
0116         __entry->to_proc = to_proc;
0117         __entry->to_thread = to_thread;
0118         __entry->code = t->code;
0119         __entry->flags = t->flags;
0120     ),
0121     TP_printk("transaction=%d from %d:%d to %d:%d flags=0x%x code=0x%x",
0122           __entry->debug_id, __entry->from_proc, __entry->from_thread,
0123           __entry->to_proc, __entry->to_thread, __entry->code,
0124           __entry->flags)
0125 );
0126
0127 TRACE_EVENT(binder_transaction,
0128     TP_PROTO(bool reply, struct binder_transaction *t,
0129          struct binder_node *target_node),
0130     TP_ARGS(reply, t, target_node),
0131     TP_STRUCT__entry(
0132         __field(int, debug_id)
0133         __field(int, target_node)
0134         __field(int, to_proc)
0135         __field(int, to_thread)
0136         __field(int, reply)
0137         __field(unsigned int, code)
0138         __field(unsigned int, flags)
0139     ),
0140     TP_fast_assign(
0141         __entry->debug_id = t->debug_id;
0142         __entry->target_node = target_node ? target_node->debug_id : 0;
0143         __entry->to_proc = t->to_proc->pid;
0144         __entry->to_thread = t->to_thread ? t->to_thread->pid : 0;
0145         __entry->reply = reply;
0146         __entry->code = t->code;
0147         __entry->flags = t->flags;
0148     ),
0149     TP_printk("transaction=%d dest_node=%d dest_proc=%d dest_thread=%d reply=%d flags=0x%x code=0x%x",
0150           __entry->debug_id, __entry->target_node,
0151           __entry->to_proc, __entry->to_thread,
0152           __entry->reply, __entry->flags, __entry->code)
0153 );
0154
0155 TRACE_EVENT(binder_transaction_received,
0156     TP_PROTO(struct binder_transaction *t),
0157     TP_ARGS(t),
0158
0159     TP_STRUCT__entry(
0160         __field(int, debug_id)
0161     ),
0162     TP_fast_assign(
0163         __entry->debug_id = t->debug_id;
0164     ),
0165     TP_printk("transaction=%d", __entry->debug_id)
0166 );
0167
0168 TRACE_EVENT(binder_transaction_node_to_ref,
0169     TP_PROTO(struct binder_transaction *t, struct binder_node *node,
0170          struct binder_ref_data *rdata),
0171     TP_ARGS(t, node, rdata),
0172
0173     TP_STRUCT__entry(
0174         __field(int, debug_id)
0175         __field(int, node_debug_id)
0176         __field(binder_uintptr_t, node_ptr)
0177         __field(int, ref_debug_id)
0178         __field(uint32_t, ref_desc)
0179     ),
0180     TP_fast_assign(
0181         __entry->debug_id = t->debug_id;
0182         __entry->node_debug_id = node->debug_id;
0183         __entry->node_ptr = node->ptr;
0184         __entry->ref_debug_id = rdata->debug_id;
0185         __entry->ref_desc = rdata->desc;
0186     ),
0187     TP_printk("transaction=%d node=%d src_ptr=0x%016llx ==> dest_ref=%d dest_desc=%d",
0188           __entry->debug_id, __entry->node_debug_id,
0189           (u64)__entry->node_ptr,
0190           __entry->ref_debug_id, __entry->ref_desc)
0191 );
0192
0193 TRACE_EVENT(binder_transaction_ref_to_node,
0194     TP_PROTO(struct binder_transaction *t, struct binder_node *node,
0195          struct binder_ref_data *rdata),
0196     TP_ARGS(t, node, rdata),
0197
0198     TP_STRUCT__entry(
0199         __field(int, debug_id)
0200         __field(int, ref_debug_id)
0201         __field(uint32_t, ref_desc)
0202         __field(int, node_debug_id)
0203         __field(binder_uintptr_t, node_ptr)
0204     ),
0205     TP_fast_assign(
0206         __entry->debug_id = t->debug_id;
0207         __entry->ref_debug_id = rdata->debug_id;
0208         __entry->ref_desc = rdata->desc;
0209         __entry->node_debug_id = node->debug_id;
0210         __entry->node_ptr = node->ptr;
0211     ),
0212     TP_printk("transaction=%d node=%d src_ref=%d src_desc=%d ==> dest_ptr=0x%016llx",
0213           __entry->debug_id, __entry->node_debug_id,
0214           __entry->ref_debug_id, __entry->ref_desc,
0215           (u64)__entry->node_ptr)
0216 );
0217
0218 TRACE_EVENT(binder_transaction_ref_to_ref,
0219     TP_PROTO(struct binder_transaction *t, struct binder_node *node,
0220          struct binder_ref_data *src_ref,
0221          struct binder_ref_data *dest_ref),
0222     TP_ARGS(t, node, src_ref, dest_ref),
0223
0224     TP_STRUCT__entry(
0225         __field(int, debug_id)
0226         __field(int, node_debug_id)
0227         __field(int, src_ref_debug_id)
0228         __field(uint32_t, src_ref_desc)
0229         __field(int, dest_ref_debug_id)
0230         __field(uint32_t, dest_ref_desc)
0231     ),
0232     TP_fast_assign(
0233         __entry->debug_id = t->debug_id;
0234         __entry->node_debug_id = node->debug_id;
0235         __entry->src_ref_debug_id = src_ref->debug_id;
0236         __entry->src_ref_desc = src_ref->desc;
0237         __entry->dest_ref_debug_id = dest_ref->debug_id;
0238         __entry->dest_ref_desc = dest_ref->desc;
0239     ),
0240     TP_printk("transaction=%d node=%d src_ref=%d src_desc=%d ==> dest_ref=%d dest_desc=%d",
0241           __entry->debug_id, __entry->node_debug_id,
0242           __entry->src_ref_debug_id, __entry->src_ref_desc,
0243           __entry->dest_ref_debug_id, __entry->dest_ref_desc)
0244 );
0245
0246 TRACE_EVENT(binder_transaction_fd_send,
0247     TP_PROTO(struct binder_transaction *t, int fd, size_t offset),
0248     TP_ARGS(t, fd, offset),
0249
0250     TP_STRUCT__entry(
0251         __field(int, debug_id)
0252         __field(int, fd)
0253         __field(size_t, offset)
0254     ),
0255     TP_fast_assign(
0256         __entry->debug_id = t->debug_id;
0257         __entry->fd = fd;
0258         __entry->offset = offset;
0259     ),
0260     TP_printk("transaction=%d src_fd=%d offset=%zu",
0261           __entry->debug_id, __entry->fd, __entry->offset)
0262 );
0263
0264 TRACE_EVENT(binder_transaction_fd_recv,
0265     TP_PROTO(struct binder_transaction *t, int fd, size_t offset),
0266     TP_ARGS(t, fd, offset),
0267
0268     TP_STRUCT__entry(
0269         __field(int, debug_id)
0270         __field(int, fd)
0271         __field(size_t, offset)
0272     ),
0273     TP_fast_assign(
0274         __entry->debug_id = t->debug_id;
0275         __entry->fd = fd;
0276         __entry->offset = offset;
0277     ),
0278     TP_printk("transaction=%d dest_fd=%d offset=%zu",
0279           __entry->debug_id, __entry->fd, __entry->offset)
0280 );
0281
0282 DECLARE_EVENT_CLASS(binder_buffer_class,
0283     TP_PROTO(struct binder_buffer *buf),
0284     TP_ARGS(buf),
0285     TP_STRUCT__entry(
0286         __field(int, debug_id)
0287         __field(size_t, data_size)
0288         __field(size_t, offsets_size)
0289         __field(size_t, extra_buffers_size)
0290     ),
0291     TP_fast_assign(
0292         __entry->debug_id = buf->debug_id;
0293         __entry->data_size = buf->data_size;
0294         __entry->offsets_size = buf->offsets_size;
0295         __entry->extra_buffers_size = buf->extra_buffers_size;
0296     ),
0297     TP_printk("transaction=%d data_size=%zd offsets_size=%zd extra_buffers_size=%zd",
0298           __entry->debug_id, __entry->data_size, __entry->offsets_size,
0299           __entry->extra_buffers_size)
0300 );
0301
0302 DEFINE_EVENT(binder_buffer_class, binder_transaction_alloc_buf,
0303     TP_PROTO(struct binder_buffer *buffer),
0304     TP_ARGS(buffer));
0305
0306 DEFINE_EVENT(binder_buffer_class, binder_transaction_buffer_release,
0307     TP_PROTO(struct binder_buffer *buffer),
0308     TP_ARGS(buffer));
0309
0310 DEFINE_EVENT(binder_buffer_class, binder_transaction_failed_buffer_release,
0311     TP_PROTO(struct binder_buffer *buffer),
0312     TP_ARGS(buffer));
0313
0314 DEFINE_EVENT(binder_buffer_class, binder_transaction_update_buffer_release,
0315          TP_PROTO(struct binder_buffer *buffer),
0316          TP_ARGS(buffer));
0317
0318 TRACE_EVENT(binder_update_page_range,
0319     TP_PROTO(struct binder_alloc *alloc, bool allocate,
0320          void __user *start, void __user *end),
0321     TP_ARGS(alloc, allocate, start, end),
0322     TP_STRUCT__entry(
0323         __field(int, proc)
0324         __field(bool, allocate)
0325         __field(size_t, offset)
0326         __field(size_t, size)
0327     ),
0328     TP_fast_assign(
0329         __entry->proc = alloc->pid;
0330         __entry->allocate = allocate;
0331         __entry->offset = start - alloc->buffer;
0332         __entry->size = end - start;
0333     ),
0334     TP_printk("proc=%d allocate=%d offset=%zu size=%zu",
0335           __entry->proc, __entry->allocate,
0336           __entry->offset, __entry->size)
0337 );
0338
0339 DECLARE_EVENT_CLASS(binder_lru_page_class,
0340     TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
0341     TP_ARGS(alloc, page_index),
0342     TP_STRUCT__entry(
0343         __field(int, proc)
0344         __field(size_t, page_index)
0345     ),
0346     TP_fast_assign(
0347         __entry->proc = alloc->pid;
0348         __entry->page_index = page_index;
0349     ),
0350     TP_printk("proc=%d page_index=%zu",
0351           __entry->proc, __entry->page_index)
0352 );
0353
0354 DEFINE_EVENT(binder_lru_page_class, binder_alloc_lru_start,
0355     TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
0356     TP_ARGS(alloc, page_index));
0357
0358 DEFINE_EVENT(binder_lru_page_class, binder_alloc_lru_end,
0359     TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
0360     TP_ARGS(alloc, page_index));
0361
0362 DEFINE_EVENT(binder_lru_page_class, binder_free_lru_start,
0363     TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
0364     TP_ARGS(alloc, page_index));
0365
0366 DEFINE_EVENT(binder_lru_page_class, binder_free_lru_end,
0367     TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
0368     TP_ARGS(alloc, page_index));
0369
0370 DEFINE_EVENT(binder_lru_page_class, binder_alloc_page_start,
0371     TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
0372     TP_ARGS(alloc, page_index));
0373
0374 DEFINE_EVENT(binder_lru_page_class, binder_alloc_page_end,
0375     TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
0376     TP_ARGS(alloc, page_index));
0377
0378 DEFINE_EVENT(binder_lru_page_class, binder_unmap_user_start,
0379     TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
0380     TP_ARGS(alloc, page_index));
0381
0382 DEFINE_EVENT(binder_lru_page_class, binder_unmap_user_end,
0383     TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
0384     TP_ARGS(alloc, page_index));
0385
0386 DEFINE_EVENT(binder_lru_page_class, binder_unmap_kernel_start,
0387     TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
0388     TP_ARGS(alloc, page_index));
0389
0390 DEFINE_EVENT(binder_lru_page_class, binder_unmap_kernel_end,
0391     TP_PROTO(const struct binder_alloc *alloc, size_t page_index),
0392     TP_ARGS(alloc, page_index));
0393
0394 TRACE_EVENT(binder_command,
0395     TP_PROTO(uint32_t cmd),
0396     TP_ARGS(cmd),
0397     TP_STRUCT__entry(
0398         __field(uint32_t, cmd)
0399     ),
0400     TP_fast_assign(
0401         __entry->cmd = cmd;
0402     ),
0403     TP_printk("cmd=0x%x %s",
0404           __entry->cmd,
0405           _IOC_NR(__entry->cmd) < ARRAY_SIZE(binder_command_strings) ?
0406               binder_command_strings[_IOC_NR(__entry->cmd)] :
0407               "unknown")
0408 );
0409
0410 TRACE_EVENT(binder_return,
0411     TP_PROTO(uint32_t cmd),
0412     TP_ARGS(cmd),
0413     TP_STRUCT__entry(
0414         __field(uint32_t, cmd)
0415     ),
0416     TP_fast_assign(
0417         __entry->cmd = cmd;
0418     ),
0419     TP_printk("cmd=0x%x %s",
0420           __entry->cmd,
0421           _IOC_NR(__entry->cmd) < ARRAY_SIZE(binder_return_strings) ?
0422               binder_return_strings[_IOC_NR(__entry->cmd)] :
0423               "unknown")
0424 );
0425
0426 #endif /* _BINDER_TRACE_H */
0427
0428 #undef TRACE_INCLUDE_PATH
0429 #undef TRACE_INCLUDE_FILE
0430 #define TRACE_INCLUDE_PATH .
0431 #define TRACE_INCLUDE_FILE binder_trace
0432 #include <trace/define_trace.h>