Commit | Line | Data |
---|---|---|
88071539 TH |
1 | /************************************************************************** |
2 | * | |
3 | * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA | |
4 | * All Rights Reserved. | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a | |
7 | * copy of this software and associated documentation files (the | |
8 | * "Software"), to deal in the Software without restriction, including | |
9 | * without limitation the rights to use, copy, modify, merge, publish, | |
10 | * distribute, sub license, and/or sell copies of the Software, and to | |
11 | * permit persons to whom the Software is furnished to do so, subject to | |
12 | * the following conditions: | |
13 | * | |
14 | * The above copyright notice and this permission notice (including the | |
15 | * next paragraph) shall be included in all copies or substantial portions | |
16 | * of the Software. | |
17 | * | |
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
20 | * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL | |
21 | * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, | |
22 | * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR | |
23 | * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE | |
24 | * USE OR OTHER DEALINGS IN THE SOFTWARE. | |
25 | * | |
26 | **************************************************************************/ | |
27 | /* | |
28 | * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com> | |
29 | */ | |
30 | /** @file ttm_object.h | |
31 | * | |
32 | * Base- and reference object implementation for the various | |
33 | * ttm objects. Implements reference counting, minimal security checks | |
34 | * and release on file close. | |
35 | */ | |
36 | ||
37 | #ifndef _TTM_OBJECT_H_ | |
38 | #define _TTM_OBJECT_H_ | |
39 | ||
40 | #include <linux/list.h> | |
a1ce3928 | 41 | #include <drm/drm_hashtab.h> |
88071539 | 42 | #include <linux/kref.h> |
cdad0521 | 43 | #include <linux/rcupdate.h> |
65981f76 | 44 | #include <linux/dma-buf.h> |
88071539 TH |
45 | #include <ttm/ttm_memory.h> |
46 | ||
47 | /** | |
48 | * enum ttm_ref_type | |
49 | * | |
50 | * Describes what type of reference a ref object holds. | |
51 | * | |
52 | * TTM_REF_USAGE is a simple refcount on a base object. | |
53 | * | |
54 | * TTM_REF_SYNCCPU_READ is a SYNCCPU_READ reference on a | |
55 | * buffer object. | |
56 | * | |
57 | * TTM_REF_SYNCCPU_WRITE is a SYNCCPU_WRITE reference on a | |
58 | * buffer object. | |
59 | * | |
60 | */ | |
61 | ||
62 | enum ttm_ref_type { | |
63 | TTM_REF_USAGE, | |
64 | TTM_REF_SYNCCPU_READ, | |
65 | TTM_REF_SYNCCPU_WRITE, | |
66 | TTM_REF_NUM | |
67 | }; | |
68 | ||
69 | /** | |
70 | * enum ttm_object_type | |
71 | * | |
72 | * One entry per ttm object type. | |
73 | * Device-specific types should use the | |
74 | * ttm_driver_typex types. | |
75 | */ | |
76 | ||
77 | enum ttm_object_type { | |
78 | ttm_fence_type, | |
79 | ttm_buffer_type, | |
80 | ttm_lock_type, | |
65981f76 | 81 | ttm_prime_type, |
88071539 | 82 | ttm_driver_type0 = 256, |
be1cb868 JB |
83 | ttm_driver_type1, |
84 | ttm_driver_type2, | |
85 | ttm_driver_type3, | |
86 | ttm_driver_type4, | |
87 | ttm_driver_type5 | |
88071539 TH |
88 | }; |
89 | ||
90 | struct ttm_object_file; | |
91 | struct ttm_object_device; | |
92 | ||
93 | /** | |
94 | * struct ttm_base_object | |
95 | * | |
96 | * @hash: hash entry for the per-device object hash. | |
97 | * @type: derived type this object is base class for. | |
98 | * @shareable: Other ttm_object_files can access this object. | |
99 | * | |
100 | * @tfile: Pointer to ttm_object_file of the creator. | |
101 | * NULL if the object was not created by a user request. | |
102 | * (kernel object). | |
103 | * | |
104 | * @refcount: Number of references to this object, not | |
105 | * including the hash entry. A reference to a base object can | |
106 | * only be held by a ref object. | |
107 | * | |
108 | * @refcount_release: A function to be called when there are | |
109 | * no more references to this object. This function should | |
110 | * destroy the object (or make sure destruction eventually happens), | |
111 | * and when it is called, the object has | |
112 | * already been taken out of the per-device hash. The parameter | |
113 | * "base" should be set to NULL by the function. | |
114 | * | |
115 | * @ref_obj_release: A function to be called when a reference object | |
116 | * with another ttm_ref_type than TTM_REF_USAGE is deleted. | |
0d74f86f | 117 | * This function may, for example, release a lock held by a user-space |
88071539 TH |
118 | * process. |
119 | * | |
120 | * This struct is intended to be used as a base struct for objects that | |
121 | * are visible to user-space. It provides a global name, race-safe | |
122 | * access and refcounting, minimal access contol and hooks for unref actions. | |
123 | */ | |
124 | ||
125 | struct ttm_base_object { | |
cdad0521 | 126 | struct rcu_head rhead; |
88071539 TH |
127 | struct drm_hash_item hash; |
128 | enum ttm_object_type object_type; | |
129 | bool shareable; | |
130 | struct ttm_object_file *tfile; | |
131 | struct kref refcount; | |
132 | void (*refcount_release) (struct ttm_base_object **base); | |
133 | void (*ref_obj_release) (struct ttm_base_object *base, | |
134 | enum ttm_ref_type ref_type); | |
135 | }; | |
136 | ||
65981f76 TH |
137 | |
138 | /** | |
139 | * struct ttm_prime_object - Modified base object that is prime-aware | |
140 | * | |
141 | * @base: struct ttm_base_object that we derive from | |
142 | * @mutex: Mutex protecting the @dma_buf member. | |
143 | * @size: Size of the dma_buf associated with this object | |
144 | * @real_type: Type of the underlying object. Needed since we're setting | |
145 | * the value of @base::object_type to ttm_prime_type | |
146 | * @dma_buf: Non ref-coutned pointer to a struct dma_buf created from this | |
147 | * object. | |
148 | * @refcount_release: The underlying object's release method. Needed since | |
149 | * we set @base::refcount_release to our own release method. | |
150 | */ | |
151 | ||
152 | struct ttm_prime_object { | |
153 | struct ttm_base_object base; | |
154 | struct mutex mutex; | |
155 | size_t size; | |
156 | enum ttm_object_type real_type; | |
157 | struct dma_buf *dma_buf; | |
158 | void (*refcount_release) (struct ttm_base_object **); | |
159 | }; | |
160 | ||
88071539 TH |
161 | /** |
162 | * ttm_base_object_init | |
163 | * | |
164 | * @tfile: Pointer to a struct ttm_object_file. | |
165 | * @base: The struct ttm_base_object to initialize. | |
166 | * @shareable: This object is shareable with other applcations. | |
167 | * (different @tfile pointers.) | |
168 | * @type: The object type. | |
169 | * @refcount_release: See the struct ttm_base_object description. | |
170 | * @ref_obj_release: See the struct ttm_base_object description. | |
171 | * | |
172 | * Initializes a struct ttm_base_object. | |
173 | */ | |
174 | ||
175 | extern int ttm_base_object_init(struct ttm_object_file *tfile, | |
176 | struct ttm_base_object *base, | |
177 | bool shareable, | |
178 | enum ttm_object_type type, | |
179 | void (*refcount_release) (struct ttm_base_object | |
180 | **), | |
181 | void (*ref_obj_release) (struct ttm_base_object | |
182 | *, | |
183 | enum ttm_ref_type | |
184 | ref_type)); | |
185 | ||
186 | /** | |
187 | * ttm_base_object_lookup | |
188 | * | |
189 | * @tfile: Pointer to a struct ttm_object_file. | |
190 | * @key: Hash key | |
191 | * | |
192 | * Looks up a struct ttm_base_object with the key @key. | |
193 | * Also verifies that the object is visible to the application, by | |
194 | * comparing the @tfile argument and checking the object shareable flag. | |
195 | */ | |
196 | ||
197 | extern struct ttm_base_object *ttm_base_object_lookup(struct ttm_object_file | |
198 | *tfile, uint32_t key); | |
199 | ||
200 | /** | |
201 | * ttm_base_object_unref | |
202 | * | |
0d74f86f | 203 | * @p_base: Pointer to a pointer referencing a struct ttm_base_object. |
88071539 TH |
204 | * |
205 | * Decrements the base object refcount and clears the pointer pointed to by | |
206 | * p_base. | |
207 | */ | |
208 | ||
209 | extern void ttm_base_object_unref(struct ttm_base_object **p_base); | |
210 | ||
211 | /** | |
212 | * ttm_ref_object_add. | |
213 | * | |
214 | * @tfile: A struct ttm_object_file representing the application owning the | |
215 | * ref_object. | |
216 | * @base: The base object to reference. | |
217 | * @ref_type: The type of reference. | |
218 | * @existed: Upon completion, indicates that an identical reference object | |
219 | * already existed, and the refcount was upped on that object instead. | |
220 | * | |
221 | * Adding a ref object to a base object is basically like referencing the | |
222 | * base object, but a user-space application holds the reference. When the | |
223 | * file corresponding to @tfile is closed, all its reference objects are | |
224 | * deleted. A reference object can have different types depending on what | |
225 | * it's intended for. It can be refcounting to prevent object destruction, | |
226 | * When user-space takes a lock, it can add a ref object to that lock to | |
227 | * make sure the lock is released if the application dies. A ref object | |
228 | * will hold a single reference on a base object. | |
229 | */ | |
230 | extern int ttm_ref_object_add(struct ttm_object_file *tfile, | |
231 | struct ttm_base_object *base, | |
232 | enum ttm_ref_type ref_type, bool *existed); | |
233 | /** | |
234 | * ttm_ref_object_base_unref | |
235 | * | |
236 | * @key: Key representing the base object. | |
237 | * @ref_type: Ref type of the ref object to be dereferenced. | |
238 | * | |
239 | * Unreference a ref object with type @ref_type | |
240 | * on the base object identified by @key. If there are no duplicate | |
241 | * references, the ref object will be destroyed and the base object | |
242 | * will be unreferenced. | |
243 | */ | |
244 | extern int ttm_ref_object_base_unref(struct ttm_object_file *tfile, | |
245 | unsigned long key, | |
246 | enum ttm_ref_type ref_type); | |
247 | ||
248 | /** | |
249 | * ttm_object_file_init - initialize a struct ttm_object file | |
250 | * | |
251 | * @tdev: A struct ttm_object device this file is initialized on. | |
252 | * @hash_order: Order of the hash table used to hold the reference objects. | |
253 | * | |
254 | * This is typically called by the file_ops::open function. | |
255 | */ | |
256 | ||
257 | extern struct ttm_object_file *ttm_object_file_init(struct ttm_object_device | |
258 | *tdev, | |
259 | unsigned int hash_order); | |
260 | ||
261 | /** | |
262 | * ttm_object_file_release - release data held by a ttm_object_file | |
263 | * | |
264 | * @p_tfile: Pointer to pointer to the ttm_object_file object to release. | |
265 | * *p_tfile will be set to NULL by this function. | |
266 | * | |
267 | * Releases all data associated by a ttm_object_file. | |
268 | * Typically called from file_ops::release. The caller must | |
269 | * ensure that there are no concurrent users of tfile. | |
270 | */ | |
271 | ||
272 | extern void ttm_object_file_release(struct ttm_object_file **p_tfile); | |
273 | ||
274 | /** | |
275 | * ttm_object device init - initialize a struct ttm_object_device | |
276 | * | |
65981f76 | 277 | * @mem_glob: struct ttm_mem_global for memory accounting. |
88071539 | 278 | * @hash_order: Order of hash table used to hash the base objects. |
65981f76 | 279 | * @ops: DMA buf ops for prime objects of this device. |
88071539 TH |
280 | * |
281 | * This function is typically called on device initialization to prepare | |
282 | * data structures needed for ttm base and ref objects. | |
283 | */ | |
284 | ||
65981f76 TH |
285 | extern struct ttm_object_device * |
286 | ttm_object_device_init(struct ttm_mem_global *mem_glob, | |
287 | unsigned int hash_order, | |
288 | const struct dma_buf_ops *ops); | |
88071539 TH |
289 | |
290 | /** | |
291 | * ttm_object_device_release - release data held by a ttm_object_device | |
292 | * | |
293 | * @p_tdev: Pointer to pointer to the ttm_object_device object to release. | |
294 | * *p_tdev will be set to NULL by this function. | |
295 | * | |
296 | * Releases all data associated by a ttm_object_device. | |
297 | * Typically called from driver::unload before the destruction of the | |
298 | * device private data structure. | |
299 | */ | |
300 | ||
301 | extern void ttm_object_device_release(struct ttm_object_device **p_tdev); | |
302 | ||
cdad0521 TH |
303 | #define ttm_base_object_kfree(__object, __base)\ |
304 | kfree_rcu(__object, __base.rhead) | |
65981f76 TH |
305 | |
306 | extern int ttm_prime_object_init(struct ttm_object_file *tfile, | |
307 | size_t size, | |
308 | struct ttm_prime_object *prime, | |
309 | bool shareable, | |
310 | enum ttm_object_type type, | |
311 | void (*refcount_release) | |
312 | (struct ttm_base_object **), | |
313 | void (*ref_obj_release) | |
314 | (struct ttm_base_object *, | |
315 | enum ttm_ref_type ref_type)); | |
316 | ||
317 | static inline enum ttm_object_type | |
318 | ttm_base_object_type(struct ttm_base_object *base) | |
319 | { | |
320 | return (base->object_type == ttm_prime_type) ? | |
321 | container_of(base, struct ttm_prime_object, base)->real_type : | |
322 | base->object_type; | |
323 | } | |
324 | extern int ttm_prime_fd_to_handle(struct ttm_object_file *tfile, | |
325 | int fd, u32 *handle); | |
326 | extern int ttm_prime_handle_to_fd(struct ttm_object_file *tfile, | |
327 | uint32_t handle, uint32_t flags, | |
328 | int *prime_fd); | |
329 | ||
330 | #define ttm_prime_object_kfree(__obj, __prime) \ | |
331 | kfree_rcu(__obj, __prime.base.rhead) | |
88071539 | 332 | #endif |