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>
24 #include <linux/list_lru.h>
26 extern struct list_lru binder_alloc_lru;
27 struct binder_transaction;
30 * struct binder_buffer - buffer used for binder transactions
31 * @entry: entry alloc->buffers
32 * @rb_node: node for allocated_buffers/free_buffers rb trees
33 * @free: true if buffer is free
34 * @allow_user_free: describe the second member of struct blah,
35 * @async_transaction: describe the second member of struct blah,
36 * @debug_id: describe the second member of struct blah,
37 * @transaction: describe the second member of struct blah,
38 * @target_node: describe the second member of struct blah,
39 * @data_size: describe the second member of struct blah,
40 * @offsets_size: describe the second member of struct blah,
41 * @extra_buffers_size: describe the second member of struct blah,
42 * @data:i describe the second member of struct blah,
44 * Bookkeeping structure for binder transaction buffers
46 struct binder_buffer {
47 struct list_head entry; /* free and allocated entries by address */
48 struct rb_node rb_node; /* free entry by size or allocated entry */
51 unsigned allow_user_free:1;
52 unsigned async_transaction:1;
55 struct binder_transaction *transaction;
57 struct binder_node *target_node;
60 size_t extra_buffers_size;
65 * struct binder_lru_page - page object used for binder shrinker
66 * @page_ptr: pointer to physical page in mmap'd space
67 * @lru: entry in binder_alloc_lru
68 * @alloc: binder_alloc for a proc
70 struct binder_lru_page {
72 struct page *page_ptr;
73 struct binder_alloc *alloc;
77 * struct binder_alloc - per-binder proc state for binder allocator
78 * @vma: vm_area_struct passed to mmap_handler
79 * (invarient after mmap)
80 * @tsk: tid for task that called init for this proc
81 * (invariant after init)
82 * @vma_vm_mm: copy of vma->vm_mm (invarient after mmap)
83 * @buffer: base of per-proc address space mapped via mmap
84 * @user_buffer_offset: offset between user and kernel VAs for buffer
85 * @buffers: list of all buffers for this proc
86 * @free_buffers: rb tree of buffers available for allocation
88 * @allocated_buffers: rb tree of allocated buffers sorted by address
89 * @free_async_space: VA space available for async buffers. This is
90 * initialized at mmap time to 1/2 the full VA space
91 * @pages: array of binder_lru_page
92 * @buffer_size: size of address space specified via mmap
93 * @pid: pid for associated binder_proc (invariant after init)
95 * Bookkeeping structure for per-proc address space management for binder
96 * buffers. It is normally initialized during binder_init() and binder_mmap()
97 * calls. The address space is used for both user-visible buffers and for
98 * struct binder_buffer objects used to track the user buffers
100 struct binder_alloc {
102 struct vm_area_struct *vma;
103 struct mm_struct *vma_vm_mm;
105 ptrdiff_t user_buffer_offset;
106 struct list_head buffers;
107 struct rb_root free_buffers;
108 struct rb_root allocated_buffers;
109 size_t free_async_space;
110 struct binder_lru_page *pages;
112 uint32_t buffer_free;
116 #ifdef CONFIG_ANDROID_BINDER_IPC_SELFTEST
117 void binder_selftest_alloc(struct binder_alloc *alloc);
119 static inline void binder_selftest_alloc(struct binder_alloc *alloc) {}
121 enum lru_status binder_alloc_free_page(struct list_head *item,
122 struct list_lru_one *lru,
123 spinlock_t *lock, void *cb_arg);
124 extern struct binder_buffer *binder_alloc_new_buf(struct binder_alloc *alloc,
127 size_t extra_buffers_size,
129 extern void binder_alloc_init(struct binder_alloc *alloc);
130 void binder_alloc_shrinker_init(void);
131 extern void binder_alloc_vma_close(struct binder_alloc *alloc);
132 extern struct binder_buffer *
133 binder_alloc_prepare_to_free(struct binder_alloc *alloc,
135 extern void binder_alloc_free_buf(struct binder_alloc *alloc,
136 struct binder_buffer *buffer);
137 extern int binder_alloc_mmap_handler(struct binder_alloc *alloc,
138 struct vm_area_struct *vma);
139 extern void binder_alloc_deferred_release(struct binder_alloc *alloc);
140 extern int binder_alloc_get_allocated_count(struct binder_alloc *alloc);
141 extern void binder_alloc_print_allocated(struct seq_file *m,
142 struct binder_alloc *alloc);
143 void binder_alloc_print_pages(struct seq_file *m,
144 struct binder_alloc *alloc);
147 * binder_alloc_get_free_async_space() - get free space available for async
148 * @alloc: binder_alloc for this proc
150 * Return: the bytes remaining in the address-space for async transactions
153 binder_alloc_get_free_async_space(struct binder_alloc *alloc)
155 size_t free_async_space;
157 mutex_lock(&alloc->mutex);
158 free_async_space = alloc->free_async_space;
159 mutex_unlock(&alloc->mutex);
160 return free_async_space;
164 * binder_alloc_get_user_buffer_offset() - get offset between kernel/user addrs
165 * @alloc: binder_alloc for this proc
167 * Return: the offset between kernel and user-space addresses to use for
168 * virtual address conversion
170 static inline ptrdiff_t
171 binder_alloc_get_user_buffer_offset(struct binder_alloc *alloc)
174 * user_buffer_offset is constant if vma is set and
175 * undefined if vma is not set. It is possible to
176 * get here with !alloc->vma if the target process
177 * is dying while a transaction is being initiated.
178 * Returning the old value is ok in this case and
179 * the transaction will fail.
181 return alloc->user_buffer_offset;
184 #endif /* _LINUX_BINDER_ALLOC_H */