Commit | Line | Data |
---|---|---|
0c972a05 TK |
1 | /* |
2 | * Copyright (C) 2017 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 | #ifndef _LINUX_BINDER_ALLOC_H | |
16 | #define _LINUX_BINDER_ALLOC_H | |
17 | ||
18 | #include <linux/rbtree.h> | |
19 | #include <linux/list.h> | |
20 | #include <linux/mm.h> | |
21 | #include <linux/rtmutex.h> | |
22 | #include <linux/vmalloc.h> | |
23 | #include <linux/slab.h> | |
24 | ||
25 | struct binder_transaction; | |
26 | ||
27 | /** | |
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, | |
41 | * | |
42 | * Bookkeeping structure for binder transaction buffers | |
43 | */ | |
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 */ | |
47 | /* by address */ | |
48 | unsigned free:1; | |
49 | unsigned allow_user_free:1; | |
50 | unsigned async_transaction:1; | |
53d311cf TK |
51 | unsigned free_in_progress:1; |
52 | unsigned debug_id:28; | |
0c972a05 TK |
53 | |
54 | struct binder_transaction *transaction; | |
55 | ||
56 | struct binder_node *target_node; | |
57 | size_t data_size; | |
58 | size_t offsets_size; | |
59 | size_t extra_buffers_size; | |
60 | uint8_t data[0]; | |
61 | }; | |
62 | ||
63 | /** | |
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 | |
74 | * sorted by size | |
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) | |
82 | * | |
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 | |
87 | */ | |
88 | struct binder_alloc { | |
89 | struct mutex mutex; | |
90 | struct task_struct *tsk; | |
91 | struct vm_area_struct *vma; | |
92 | struct mm_struct *vma_vm_mm; | |
93 | void *buffer; | |
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; | |
99 | struct page **pages; | |
100 | size_t buffer_size; | |
101 | uint32_t buffer_free; | |
102 | int pid; | |
103 | }; | |
104 | ||
105 | extern struct binder_buffer *binder_alloc_new_buf(struct binder_alloc *alloc, | |
106 | size_t data_size, | |
107 | size_t offsets_size, | |
108 | size_t extra_buffers_size, | |
109 | int is_async); | |
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 * | |
53d311cf TK |
113 | binder_alloc_prepare_to_free(struct binder_alloc *alloc, |
114 | uintptr_t user_ptr); | |
0c972a05 TK |
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); | |
123 | ||
124 | /** | |
125 | * binder_alloc_get_free_async_space() - get free space available for async | |
126 | * @alloc: binder_alloc for this proc | |
127 | * | |
128 | * Return: the bytes remaining in the address-space for async transactions | |
129 | */ | |
130 | static inline size_t | |
131 | binder_alloc_get_free_async_space(struct binder_alloc *alloc) | |
132 | { | |
133 | size_t free_async_space; | |
134 | ||
135 | mutex_lock(&alloc->mutex); | |
136 | free_async_space = alloc->free_async_space; | |
137 | mutex_unlock(&alloc->mutex); | |
138 | return free_async_space; | |
139 | } | |
140 | ||
141 | /** | |
142 | * binder_alloc_get_user_buffer_offset() - get offset between kernel/user addrs | |
143 | * @alloc: binder_alloc for this proc | |
144 | * | |
145 | * Return: the offset between kernel and user-space addresses to use for | |
146 | * virtual address conversion | |
147 | */ | |
148 | static inline ptrdiff_t | |
149 | binder_alloc_get_user_buffer_offset(struct binder_alloc *alloc) | |
150 | { | |
151 | /* | |
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. | |
158 | */ | |
159 | return alloc->user_buffer_offset; | |
160 | } | |
161 | ||
162 | #endif /* _LINUX_BINDER_ALLOC_H */ | |
163 |