2 * Copyright (C) 2017 Google, Inc.
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.
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.
15 #ifndef _LINUX_BINDER_ALLOC_H
16 #define _LINUX_BINDER_ALLOC_H
18 #include <linux/rbtree.h>
19 #include <linux/list.h>
21 #include <linux/rtmutex.h>
22 #include <linux/vmalloc.h>
23 #include <linux/slab.h>
25 struct binder_transaction
;
28 * struct binder_buffer - buffer used for binder transactions
29 * @entry: entry alloc->buffers
30 * @rb_node: node for allocated_buffers/free_buffers rb trees
31 * @free: true if buffer is free
32 * @allow_user_free: describe the second member of struct blah,
33 * @async_transaction: describe the second member of struct blah,
34 * @debug_id: describe the second member of struct blah,
35 * @transaction: describe the second member of struct blah,
36 * @target_node: describe the second member of struct blah,
37 * @data_size: describe the second member of struct blah,
38 * @offsets_size: describe the second member of struct blah,
39 * @extra_buffers_size: describe the second member of struct blah,
40 * @data:i describe the second member of struct blah,
42 * Bookkeeping structure for binder transaction buffers
44 struct binder_buffer
{
45 struct list_head entry
; /* free and allocated entries by address */
46 struct rb_node rb_node
; /* free entry by size or allocated entry */
49 unsigned allow_user_free
:1;
50 unsigned async_transaction
:1;
51 unsigned free_in_progress
:1;
54 struct binder_transaction
*transaction
;
56 struct binder_node
*target_node
;
59 size_t extra_buffers_size
;
64 * struct binder_alloc - per-binder proc state for binder allocator
65 * @vma: vm_area_struct passed to mmap_handler
66 * (invarient after mmap)
67 * @tsk: tid for task that called init for this proc
68 * (invariant after init)
69 * @vma_vm_mm: copy of vma->vm_mm (invarient after mmap)
70 * @buffer: base of per-proc address space mapped via mmap
71 * @user_buffer_offset: offset between user and kernel VAs for buffer
72 * @buffers: list of all buffers for this proc
73 * @free_buffers: rb tree of buffers available for allocation
75 * @allocated_buffers: rb tree of allocated buffers sorted by address
76 * @free_async_space: VA space available for async buffers. This is
77 * initialized at mmap time to 1/2 the full VA space
78 * @pages: array of physical page addresses for each
79 * page of mmap'd space
80 * @buffer_size: size of address space specified via mmap
81 * @pid: pid for associated binder_proc (invariant after init)
83 * Bookkeeping structure for per-proc address space management for binder
84 * buffers. It is normally initialized during binder_init() and binder_mmap()
85 * calls. The address space is used for both user-visible buffers and for
86 * struct binder_buffer objects used to track the user buffers
90 struct task_struct
*tsk
;
91 struct vm_area_struct
*vma
;
92 struct mm_struct
*vma_vm_mm
;
94 ptrdiff_t user_buffer_offset
;
95 struct list_head buffers
;
96 struct rb_root free_buffers
;
97 struct rb_root allocated_buffers
;
98 size_t free_async_space
;
101 uint32_t buffer_free
;
105 extern struct binder_buffer
*binder_alloc_new_buf(struct binder_alloc
*alloc
,
108 size_t extra_buffers_size
,
110 extern void binder_alloc_init(struct binder_alloc
*alloc
);
111 extern void binder_alloc_vma_close(struct binder_alloc
*alloc
);
112 extern struct binder_buffer
*
113 binder_alloc_prepare_to_free(struct binder_alloc
*alloc
,
115 extern void binder_alloc_free_buf(struct binder_alloc
*alloc
,
116 struct binder_buffer
*buffer
);
117 extern int binder_alloc_mmap_handler(struct binder_alloc
*alloc
,
118 struct vm_area_struct
*vma
);
119 extern void binder_alloc_deferred_release(struct binder_alloc
*alloc
);
120 extern int binder_alloc_get_allocated_count(struct binder_alloc
*alloc
);
121 extern void binder_alloc_print_allocated(struct seq_file
*m
,
122 struct binder_alloc
*alloc
);
125 * binder_alloc_get_free_async_space() - get free space available for async
126 * @alloc: binder_alloc for this proc
128 * Return: the bytes remaining in the address-space for async transactions
131 binder_alloc_get_free_async_space(struct binder_alloc
*alloc
)
133 size_t free_async_space
;
135 mutex_lock(&alloc
->mutex
);
136 free_async_space
= alloc
->free_async_space
;
137 mutex_unlock(&alloc
->mutex
);
138 return free_async_space
;
142 * binder_alloc_get_user_buffer_offset() - get offset between kernel/user addrs
143 * @alloc: binder_alloc for this proc
145 * Return: the offset between kernel and user-space addresses to use for
146 * virtual address conversion
148 static inline ptrdiff_t
149 binder_alloc_get_user_buffer_offset(struct binder_alloc
*alloc
)
152 * user_buffer_offset is constant if vma is set and
153 * undefined if vma is not set. It is possible to
154 * get here with !alloc->vma if the target process
155 * is dying while a transaction is being initiated.
156 * Returning the old value is ok in this case and
157 * the transaction will fail.
159 return alloc
->user_buffer_offset
;
162 #endif /* _LINUX_BINDER_ALLOC_H */