Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 35142ad7 authored by TARKZiM's avatar TARKZiM
Browse files

binder: Add missing headers

parent 0607500f

drivers/staging/android/binder.h

0 → 100644
+30 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2008 Google, Inc.

 *

 * Based on, but no longer compatible with, the original

 * OpenBinder.org binder driver interface, which is:

 *

 * Copyright (c) 2005 Palmsource, 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.

 *

 */



#ifndef _LINUX_BINDER_H

#define _LINUX_BINDER_H



#ifdef CONFIG_ANDROID_BINDER_IPC_32BIT

#define BINDER_IPC_32BIT 1

#endif



#include "uapi/binder.h"



#endif /* _LINUX_BINDER_H */

drivers/staging/android/binder_trace.h

0 → 100644
+411 −0
Original line number Diff line number Diff line 
/*

 * 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_set_priority,

	TP_PROTO(int proc, int thread, unsigned int old_prio,

		 unsigned int desired_prio, unsigned int new_prio),

	TP_ARGS(proc, thread, old_prio, new_prio, desired_prio),



	TP_STRUCT__entry(

		__field(int, proc)

		__field(int, thread)

		__field(unsigned int, old_prio)

		__field(unsigned int, new_prio)

		__field(unsigned int, desired_prio)

	),

	TP_fast_assign(

		__entry->proc = proc;

		__entry->thread = thread;

		__entry->old_prio = old_prio;

		__entry->new_prio = new_prio;

		__entry->desired_prio = desired_prio;

	),

	TP_printk("proc=%d thread=%d old=%d => new=%d desired=%d",

		  __entry->proc, __entry->thread, __entry->old_prio,

		  __entry->new_prio, __entry->desired_prio)

);



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,

	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_alloc *alloc, bool allocate,

		 void *start, void *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>